O que é?

O TheBrain é um software de mapas mentais e de gestão de conhecimento pessoal da TheBrain Technologies, de Los Angeles. Em vez de guardar informações em pastas, ele guarda pensamentos (thoughts) e as ligações entre eles, e mostra tudo numa interface gráfica dinâmica que mistura hierarquia e rede. ^{[1] [2]}

Cada pensamento pode ter notas, arquivos, links da web e eventos de calendário. Quando você clica num pensamento, ele vai para o centro da tela e os vizinhos se reorganizam em volta. Esse arranjo se chama Plex: ^{[2] [14]}

A diferença para um mapa mental comum é que um pensamento pode ter vários pais. “Parafuso M8x30” pode estar, ao mesmo tempo, em “Parafusos” e em “Kit de montagem da bomba”, sem cópia. Na prática, é um grafo de conhecimento que você desenha à mão ou por API. ^{[2] [12]}

O vocabulário que vamos usar: ^{[12] [14]}

Cérebro (brain)

A base com todos os pensamentos. Todo cérebro tem um pensamento inicial (home).

Pensamento (thought)

O nó do grafo: tem nome e, opcionalmente, rótulo, tipo, tags, nota e anexos.

Ligação (link)

A relação entre dois pensamentos. Pode ter nome, cor e tipo.

Pai e filho

Ligação hierárquica. Um filho pode ter vários pais.

Salto (jump)

Ligação lateral, sem hierarquia: “está relacionado a”.

Irmãos (siblings)

Pensamentos com o mesmo pai. Não são uma ligação própria.

Tipo (type)

A classificação principal: o que o pensamento é. Cada pensamento tem no máximo um tipo.

Tag

Um marcador transversal, como “Crítica”. Um pensamento pode ter várias.

Plex

A visão em que o pensamento ativo fica no centro, cercado pelos vizinhos.

Como surgiu?

A ideia nasceu em 1993, com Harlan Hugh, que sentia a necessidade de focar nas conexões entre as informações, e não nas separações. Em 1996 ele fundou a Natrificial Software Technologies, na Califórnia. A empresa depois passou a se chamar The Brain e, mais tarde, TheBrain Technologies, com sede em Los Angeles e Hugh ainda como CEO. ^{[1] [4]}

“A sua tela não deveria parecer um monte de botões bonitos. Deveria ser uma representação dinâmica, uma experiência, de tudo o que é importante para você.”

Harlan Hugh, à revista Feed, em 1999 ^[1]

Por muitos anos, o produto de uso pessoal se chamou PersonalBrain. A empresa também vendeu versões corporativas, como o TeamBrain e o BrainEKP, premiado em 2008. Com a versão 8, anunciada em 20 de novembro de 2013, o nome passou a ser só TheBrain, e a sincronização entre máquinas entrou num plano de serviço anual. ^{[2] [3] [5]}

Em novembro de 2023 chegou a API REST, que permite ler e gravar pensamentos por programa. Em 2026, o TheBrain 15 trouxe a IA Cerebro, novas visões (cartões, mapa mental e árvore) e o mesmo código na web, no Windows, no macOS, no iPhone/iPad e no Android. Trouxe também uma API local, servida pelo próprio aplicativo. O aplicativo completo passou a ser gratuito, e os planos pagos ficaram com a sincronização, a IA e a colaboração. ^{[6] [7] [8] [10] [11]}

Como instalar?

Há dois caminhos. No local, os cérebros ficam na sua máquina ou no seu cluster. No remoto, ficam na nuvem da TheBrain. Os dois se combinam: o desktop pode sincronizar com a nuvem, e a API funciona dos dois lados.

Local: o aplicativo nativo

É o caminho oficial e o mais simples. Em thebrain.com/download há instaladores para Windows (.exe, .msi ou .zip, a partir do Windows 10) e links para Mac, Linux e celular. Não é preciso conta nem cartão de crédito. ^[11]

1. Baixe o instalador da sua plataforma.
2. Instale e abra o TheBrain.
3. Crie um cérebro. Ele nasce com um pensamento inicial.
4. Se for usar a API local, abra Configurações › Usuário › API local. Lá ficam o endereço e a documentação. É preciso ter a versão 15.0.534 ou posterior. ^[10]

Local: Docker

A TheBrain não publica imagem Docker, e o TheBrain é um aplicativo de desktop, não um servidor. Mesmo assim, dá para conteinerizar duas coisas diferentes, e vale separar bem cada uma:

• O próprio desktop, dentro de uma área de trabalho Linux acessível pelo navegador. Aqui uso a imagem webtop, da LinuxServer.io, que entrega um XFCE pelo KasmVNC na porta 3001, com HTTPS. ^[17]
• A automação: um contêiner com um script que lê e grava no cérebro pela API. É a parte mais útil no dia a dia, e é a que usaremos no exemplo de peças.

O arquivo compose.yaml

services:
  thebrain:
    image: lscr.io/linuxserver/webtop:ubuntu-xfce
    container_name: thebrain
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Sao_Paulo
      - CUSTOM_USER=giovani
      - PASSWORD=${WEBTOP_PASSWORD}
    volumes:
      - ./thebrain-config:/config
    ports:
      - "127.0.0.1:3001:3001"
    shm_size: "1gb"
    restart: unless-stopped

  importador:
    build: ./importador
    profiles: ["ferramentas"]
    environment:
      - THEBRAIN_API_KEY
      - THEBRAIN_BRAIN_ID
      - THEBRAIN_API_URL=https://api.bra.in
      - PECAS_CSV=/dados/pecas.csv
    volumes:
      - ./dados:/dados:ro

• PUID e PGID definem o dono dos arquivos em ./thebrain-config; TZ, o fuso horário.
• CUSTOM_USER e PASSWORD ativam a autenticação básica. A senha vem de uma variável de ambiente, e não do arquivo.
• A porta é publicada só em 127.0.0.1. A documentação do webtop avisa que o terminal dele dá sudo sem senha e que ele não deve ir para a internet sem um proxy reverso com autenticação forte. ^[17]
• shm_size aumenta a memória compartilhada, que o navegador interno usa.
• O importador fica no perfil ferramentas: não sobe com o up, só quando é chamado. ^[18]

Subindo e instalando o TheBrain

O read -rs pede a senha sem mostrá-la e sem gravá-la no histórico do shell:

read -rs WEBTOP_PASSWORD && export WEBTOP_PASSWORD
docker compose up -d thebrain

Abra https://localhost:3001, aceite o certificado autoassinado e entre com o usuário e a senha. Na área de trabalho que aparece, baixe o pacote Linux em thebrain.com/download e instale-o.

Cuidado com a persistência: só /config sobrevive quando o contêiner é recriado. Se o pacote se extrai numa pasta, guarde a pasta dentro de /config. Se ele se instala no sistema, como um .deb, crie uma imagem derivada (o nome do arquivo abaixo é ilustrativo) e troque image: por build: no Compose:

FROM lscr.io/linuxserver/webtop:ubuntu-xfce
COPY thebrain-linux.deb /tmp/
RUN apt-get update \
 && apt-get install -y /tmp/thebrain-linux.deb \
 && rm -rf /tmp/thebrain-linux.deb /var/lib/apt/lists/*

O importador

O importador é o script da seção de peças, numa imagem Python enxuta:

FROM python:3.12-slim
WORKDIR /app
RUN pip install --no-cache-dir requests
COPY importa_pecas.py .
CMD ["python", "importa_pecas.py"]

read -rs THEBRAIN_API_KEY && export THEBRAIN_API_KEY
export THEBRAIN_BRAIN_ID=00000000-0000-0000-0000-000000000000
docker compose run --rm importador

Ele fala com a API na nuvem (api.bra.in), que funciona com qualquer cérebro sincronizado. Para usar a API local, troque THEBRAIN_API_URL pelo endereço que aparece em Configurações › Usuário › API local. Se ela só aceitar conexões do próprio computador, rode o script dentro da área de trabalho do webtop. ^{[10] [12]}

Local: Kubernetes

No Kubernetes, a ideia é a mesma, traduzida em objetos: um Deployment com o webtop, um PersistentVolumeClaim para /config, um Service interno e um CronJob que roda o importador todas as noites. A senha e a chave da API ficam em Secrets. ^{[19] [20] [21] [22]}

apiVersion: v1
kind: Namespace
metadata:
  name: thebrain
---
apiVersion: v1
kind: Secret
metadata:
  name: webtop
  namespace: thebrain
type: Opaque
stringData:
  PASSWORD: "CHANGE-ME"
---
apiVersion: v1
kind: Secret
metadata:
  name: thebrain-api
  namespace: thebrain
type: Opaque
stringData:
  THEBRAIN_API_KEY: "CHANGE-ME"
  THEBRAIN_BRAIN_ID: "00000000-0000-0000-0000-000000000000"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: thebrain-config
  namespace: thebrain
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 10Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: thebrain
  namespace: thebrain
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels: {app: thebrain}
  template:
    metadata:
      labels: {app: thebrain}
    spec:
      containers:
        - name: webtop
          image: lscr.io/linuxserver/webtop:ubuntu-xfce
          env:
            - {name: PUID, value: "1000"}
            - {name: PGID, value: "1000"}
            - {name: TZ, value: America/Sao_Paulo}
            - {name: CUSTOM_USER, value: giovani}
            - name: PASSWORD
              valueFrom:
                secretKeyRef: {name: webtop, key: PASSWORD}
          ports:
            - containerPort: 3001
          resources:
            requests: {cpu: 500m, memory: 2Gi}
            limits: {memory: 4Gi}
          volumeMounts:
            - {name: config, mountPath: /config}
            - {name: shm, mountPath: /dev/shm}
      volumes:
        - name: config
          persistentVolumeClaim: {claimName: thebrain-config}
        - name: shm
          emptyDir: {medium: Memory, sizeLimit: 1Gi}
---
apiVersion: v1
kind: Service
metadata:
  name: thebrain
  namespace: thebrain
spec:
  selector: {app: thebrain}
  ports:
    - {port: 3001, targetPort: 3001}
---
apiVersion: batch/v1
kind: CronJob
metadata:
  name: importa-pecas
  namespace: thebrain
spec:
  schedule: "0 2 * * *"
  timeZone: America/Sao_Paulo
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      backoffLimit: 2
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: importador
              image: registry.exemplo.com/importador-thebrain:1.0
              envFrom:
                - secretRef: {name: thebrain-api}
              env:
                - {name: PECAS_CSV, value: /dados/pecas.csv}
              volumeMounts:
                - {name: dados, mountPath: /dados, readOnly: true}
          volumes:
            - name: dados
              configMap: {name: pecas-csv}

Três escolhas importam:

• replicas: 1 com strategy: Recreate. O cérebro é um arquivo local do aplicativo, e não um banco com vários escritores. Duas réplicas no mesmo volume corromperiam os dados; o Recreate garante que o pod antigo pare antes de o novo subir. ^[19]
• /dev/shm como emptyDir em memória faz o papel do shm_size do Compose.
• O Service é ClusterIP: nada fica exposto. O acesso é por port-forward ou, se precisar, por um Ingress com autenticação. ^[23]

Para aplicar, carregar o CSV, abrir a área de trabalho e disparar uma importação sem esperar as 2h da manhã:

kubectl apply -f thebrain.yaml
kubectl -n thebrain create configmap pecas-csv --from-file=pecas.csv
kubectl -n thebrain port-forward svc/thebrain 3001:3001
kubectl -n thebrain create job importa-agora --from=cronjob/importa-pecas

Remoto

Sem instalar nada, entre em app.thebrain.com e use o cliente web. Desde o TheBrain 15, ele tem o mesmo código e os mesmos recursos do desktop. Para ter o mesmo cérebro no computador, na web e no celular, é preciso um plano pago, que inclui a sincronização na nuvem. ^{[9] [11]}

Para programar contra a nuvem:

1. Gere uma chave em app.thebrain.com/api-keys.
2. Envie-a no cabeçalho Authorization: Bearer <chave>.
3. Consulte a documentação interativa em api.bra.in: o botão Authorize recebe a chave, e o Try it out executa cada chamada. ^[12]

O primeiro teste é listar os seus cérebros:

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  https://api.bra.in/brains

A resposta traz, para cada cérebro, o id, o name e o homeThoughtId, que é o pensamento inicial. Guarde o id: ele vai em todas as outras chamadas. ^[12]

Os primeiros passos

1. Crie um cérebro. Todo cérebro nasce com um pensamento inicial, que é a raiz da navegação. Na API, ele aparece como homeThoughtId. ^[12]

2. Crie pensamentos pelos portões. Cada pensamento tem pequenos círculos nas bordas, os portões. Cada um cria um tipo de ligação: ^[14]

3. Navegue. Clique num pensamento para torná-lo ativo: o Plex se refaz em volta dele. Para ir direto a um pensamento distante, use a busca pelo nome. ^{[14] [15]}

4. Enriqueça. Escreva notas (a API as lê e grava em Markdown), anexe arquivos, pastas e endereços da web, e use o rótulo para um dado curto, como um código. ^{[12] [14]}

5. Classifique. O tipo diz o que o pensamento é (Peça, Material) e pode definir cor e ícone; cada pensamento tem no máximo um. As tags são marcas transversais (Crítica, Obsoleta), e um pensamento pode ter várias. ^{[12] [14]}

6. Fixe o que usa sempre. Os pensamentos fixados (pins) ficam sempre à mão, seja qual for o pensamento ativo. ^[12]

7. Troque de visão. Além do Plex, o TheBrain 15 mostra o mesmo cérebro como cartões, mapa mental ou árvore, sem perder nenhuma ligação. ^[7]

Montando um exemplo

O problema: uma fábrica tem milhares de peças. Cada uma pertence a uma família (fixadores, rolamentos, vedações), é feita de um material, vem de um ou mais fornecedores e segue uma norma. As perguntas do dia a dia cruzam essas dimensões: “que peças usam aço inox?”, “o que compramos da Metalúrgica Alfa?”, “quais fixadores seguem a ISO 4017?”.

Num banco relacional, isso vira tabelas e chaves estrangeiras. No TheBrain, vira pensamentos e ligações. A correspondência é esta:

E o que o TheBrain não faz: garantir integridade (nada impede um salto errado), controlar transações ou responder a consultas agregadas, como a soma do estoque por material. Por isso, a regra do exemplo é clara: o ERP continua sendo o dono dos dados, e o TheBrain é a camada de navegação e de conhecimento, recarregada a partir de um arquivo exportado.

Criando um banco de dados para classificação de peças

1. O modelo

São cinco tipos: Categoria, Peça, Material, Fornecedor e Norma. A árvore Catálogo › categoria › subcategoria › peça classifica, e os saltos ligam cada peça ao material, ao fornecedor e à norma. Materiais, fornecedores e normas também ficam como filhos de três pensamentos-índice (Materiais, Fornecedores e Normas), presos ao pensamento inicial, para que você possa navegar a partir deles.

2. Uma peça feita à mão

Antes de automatizar, monte uma peça no aplicativo para sentir o modelo:

1. No pensamento inicial, crie o filho “Catálogo de peças”; sob ele, “Fixadores”; e, sob este, “Parafusos”.
2. Sob “Parafusos”, crie “Parafuso sextavado M8x30” e ponha PAR-M8X30 no rótulo.
3. Crie o tipo Peça e aplique-o ao pensamento.
4. Pelo portão lateral, crie os saltos para “Aço carbono”, “Metalúrgica Alfa” e “ISO 4017”.
5. Escreva a ficha técnica na nota.

3. Os dados de entrada

O resto vem de uma exportação do ERP, aqui simplificada num CSV separado por ponto e vírgula. Os fornecedores são fictícios; as normas são reais: ISO 4017 (parafusos sextavados), ISO 4032 (porcas sextavadas), ISO 7089 (arruelas lisas), ISO 15 (dimensões de rolamentos radiais) e ISO 3601-1 (anéis O-ring).

codigo;descricao;categoria;subcategoria;material;fornecedor;norma;estoque
PAR-M8X30;Parafuso sextavado M8x30;Fixadores;Parafusos;Aço carbono;Metalúrgica Alfa;ISO 4017;1200
PAR-M6X20;Parafuso sextavado M6x20;Fixadores;Parafusos;Aço inox A2-70;Metalúrgica Alfa;ISO 4017;850
POR-M8;Porca sextavada M8;Fixadores;Porcas;Aço carbono;Metalúrgica Alfa;ISO 4032;3000
ARR-8;Arruela lisa 8 mm;Fixadores;Arruelas;Aço carbono;Metalúrgica Alfa;ISO 7089;5000
ROL-6204;Rolamento de esferas 6204-2RS;Transmissão;Rolamentos;Aço cromo;Rolamentos Beta;ISO 15;80
VED-OR20;Anel O-ring 20x2 NBR 70;Vedação;Anéis O-ring;Borracha NBR;Vedações Gama;ISO 3601-1;400

4. O script de importação

O script usa só a biblioteca requests e seis endpoints da API. Ele é idempotente: antes de criar um pensamento, procura-o pelo nome exato; antes de ligar dois, verifica se a ligação já existe. Pode rodar todas as noites sem duplicar nada. ^{[12] [13]}

"""Carrega pecas.csv num cérebro do TheBrain usando a API REST."""
import csv
import os

import requests

API = os.environ.get("THEBRAIN_API_URL", "https://api.bra.in").rstrip("/")
BRAIN = os.environ["THEBRAIN_BRAIN_ID"]
CSV = os.environ.get("PECAS_CSV", "pecas.csv")
S = requests.Session()
S.headers["Authorization"] = "Bearer " + os.environ["THEBRAIN_API_KEY"]

NORMAL, TIPO = 1, 2            # kind
FILHO, PAI, SALTO = 1, 2, 3    # relation
PRIVADO = 1                    # acType
ids = {}


def vazio(r):
    return not r.ok or r.text.strip() in ("", "null")


def buscar(nome):
    if nome not in ids:
        r = S.get(f"{API}/thoughts/{BRAIN}", params={"nameExact": nome})
        ids[nome] = None if vazio(r) else r.json()["id"]
    return ids[nome]


def ligar(a, b, relacao):
    if not vazio(S.get(f"{API}/links/{BRAIN}/{a}/{b}")):
        return  # já estão ligados
    corpo = {"thoughtIdA": a, "thoughtIdB": b, "relation": relacao}
    S.post(f"{API}/links/{BRAIN}", json=corpo).raise_for_status()


def garantir(nome, origem=None, relacao=FILHO, tipo=None, rotulo=None, kind=NORMAL):
    tid = buscar(nome)
    if tid:
        if origem:
            ligar(origem, tid, relacao)
        return tid
    corpo = {"name": nome, "kind": kind, "acType": PRIVADO}
    if origem:
        corpo.update(sourceThoughtId=origem, relation=relacao)
    if tipo:
        corpo["typeId"] = tipo
    if rotulo:
        corpo["label"] = rotulo
    r = S.post(f"{API}/thoughts/{BRAIN}", json=corpo)
    r.raise_for_status()
    ids[nome] = r.json()["id"]
    return ids[nome]


home = S.get(f"{API}/brains/{BRAIN}").json()["homeThoughtId"]
tipos = {t: garantir(t, kind=TIPO)
         for t in ("Peça", "Categoria", "Material", "Fornecedor", "Norma")}
catalogo = garantir("Catálogo de peças", home)
hubs = {h: garantir(h, home) for h in ("Materiais", "Fornecedores", "Normas")}
jumps = (("material", "Material", "Materiais"),
         ("fornecedor", "Fornecedor", "Fornecedores"),
         ("norma", "Norma", "Normas"))

with open(CSV, encoding="utf-8") as f:
    for p in csv.DictReader(f, delimiter=";"):
        cat = garantir(p["categoria"], catalogo, tipo=tipos["Categoria"])
        sub = garantir(p["subcategoria"], cat, tipo=tipos["Categoria"])
        peca = garantir(p["descricao"], sub, tipo=tipos["Peça"], rotulo=p["codigo"])
        for coluna, tipo, hub in jumps:
            alvo = garantir(p[coluna], hubs[hub], tipo=tipos[tipo])
            ligar(peca, alvo, SALTO)
        nota = ("| Campo | Valor |\n|---|---|\n"
                f"| Código | {p['codigo']} |\n"
                f"| Estoque | {p['estoque']} un. |\n")
        S.post(f"{API}/notes/{BRAIN}/{peca}/update",
               json={"markdown": nota}).raise_for_status()
        print("ok:", p["codigo"], "-", p["descricao"])

Os números do script vêm da especificação da API: ^[12]

5. Rodando

python -m pip install requests
read -rs THEBRAIN_API_KEY && export THEBRAIN_API_KEY
export THEBRAIN_BRAIN_ID=00000000-0000-0000-0000-000000000000
python importa_pecas.py

ok: PAR-M8X30 - Parafuso sextavado M8x30
ok: PAR-M6X20 - Parafuso sextavado M6x20
ok: POR-M8 - Porca sextavada M8
ok: ARR-8 - Arruela lisa 8 mm
ok: ROL-6204 - Rolamento de esferas 6204-2RS
ok: VED-OR20 - Anel O-ring 20x2 NBR 70

6. Consultando

No aplicativo, clique em “Aço carbono”: os saltos mostram todas as peças feitas dele. Clique em “Metalúrgica Alfa”: aparece tudo o que ela fornece. É o equivalente visual de um JOIN. Pela API, a busca por texto e a vizinhança de um pensamento fazem o mesmo papel:

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  "https://api.bra.in/search/$THEBRAIN_BRAIN_ID?queryText=M8&maxResults=30"

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  "https://api.bra.in/thoughts/$THEBRAIN_BRAIN_ID/$MATERIAL_ID/graph"

A resposta de /graph separa parents, children, jumps, siblings, tags e links. As peças que usam o material vêm em jumps. ^[12]

7. Próximos passos

• Marque peças com as tags “Crítica” ou “Obsoleta”.
• Crie kits: um pensamento “Kit de montagem da bomba” como pai adicional das peças que o compõem.
• Anexe desenhos em PDF com POST /attachments/{brainId}/{thoughtId}/file.
• Atualize nomes, rótulos e cores com PATCH, que segue o formato JSON Patch. ^{[12] [24]}

Conclusões

• O TheBrain é, no fundo, um grafo de conhecimento com uma interface muito boa para navegar. Ele brilha quando as relações importam mais que as colunas.
• Instalar é simples no desktop e na web. Docker e Kubernetes são possíveis, mas não oficiais: servem para hospedar o desktop num servidor e, principalmente, para automatizar a carga de dados pela API.
• A API REST, na nuvem ou local, faz do TheBrain um destino de integração. O exemplo carrega uma base de peças a partir de um CSV, sem duplicar nada.
• Ele não substitui o banco relacional nem o ERP: não tem integridade, transações nem agregações. Use-o como camada de navegação e documentação, alimentada pelo sistema que é dono dos dados.
• Para tirar dúvidas, as melhores fontes são a documentação interativa da API, o guia do usuário e o fórum oficial. ^{[12] [14] [16]}

Referências

1. TheBrain Technologies, “About TheBrain”, acesso em 28/09/2026, thebrain.com/about.
2. Wikipedia (em inglês), “TheBrain”, acesso em 28/09/2026, en.wikipedia.org/wiki/TheBrain.
3. Wikipedia (em inglês), “TheBrain Technologies”, acesso em 28/09/2026, en.wikipedia.org/wiki/TheBrain_Technologies.
4. Computerworld, “Linking Your Thinking”, 31/01/2000, acesso em 28/09/2026, computerworld.com/article/1368716/linking-your-thinking.html.
5. PRWeb, “TheBrain 8 Delivers Advanced Information Management with Powerful New Knowledge Visualization Features”, 20/11/2013, acesso em 28/09/2026, prweb.com/releases/thebrain_8_delivers_advanced_information_management_with_powerful_new_knowledge_visualization_features/prweb11352059.htm.
6. TheBrain Blog, “Introducing TheBrain API”, 01/11/2023, acesso em 28/09/2026, thebrain.com/blog/introducing-thebrain-api.
7. TheBrain Technologies, “TheBrain 15 — Beyond next-gen, with Cerebro AI”, acesso em 28/09/2026, thebrain.com/products/thebrain/thebrain15.
8. TheBrain Blog, “TheBrain 15 Achieves True Cross-Platform Parity: One Codebase, Five Platforms, Full Feature Equality”, 24/04/2026, acesso em 28/09/2026, old.thebrain.com/blog/true-cross-platform-parity.
9. TheBrain Blog, “Unifying TheBrain: Version 15 Now Live on the Web”, acesso em 28/09/2026, thebrain.com/blog/unifying-thebrain.
10. TheBrain Blog, “TheBrain API: Now Fully Local and Unrestrained”, 28/04/2026, acesso em 28/09/2026, thebrain.com/blog/thebrain-api-local.
11. TheBrain Technologies, “Download TheBrain — Free, forever”, acesso em 28/09/2026, thebrain.com/download.
12. TheBrain Technologies, TheBrain API, documentação interativa, versão 1.0.5, acesso em 28/09/2026, api.bra.in.
13. TheBrainTech, “thebrain-api-quickstart-python”, GitHub, acesso em 28/09/2026, github.com/TheBrainTech/thebrain-api-quickstart-python.
14. TheBrain Technologies, TheBrain 14 User Guide (PDF), acesso em 28/09/2026, assets.thebrain.com/documents/TheBrain14/TheBrain14-User-Guide-v01.pdf.
15. TheBrain Technologies, “Tutorials”, acesso em 28/09/2026, thebrain.com/tutorials.
16. TheBrain Forums, fórum oficial, acesso em 28/09/2026, forums.thebrain.com.
17. LinuxServer.io, “webtop”, acesso em 28/09/2026, docs.linuxserver.io/images/docker-webtop.
18. Docker, “Compose file reference”, acesso em 28/09/2026, docs.docker.com/reference/compose-file.
19. Kubernetes, “Deployments”, acesso em 28/09/2026, kubernetes.io/docs/concepts/workloads/controllers/deployment.
20. Kubernetes, “Persistent Volumes”, acesso em 28/09/2026, kubernetes.io/docs/concepts/storage/persistent-volumes.
21. Kubernetes, “CronJob”, acesso em 28/09/2026, kubernetes.io/docs/concepts/workloads/controllers/cron-job.
22. Kubernetes, “Secrets”, acesso em 28/09/2026, kubernetes.io/docs/concepts/configuration/secret.
23. Kubernetes, “Use Port Forwarding to Access Applications in a Cluster”, acesso em 28/09/2026, kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster.
24. IETF, RFC 6902, “JavaScript Object Notation (JSON) Patch”, 2013, acesso em 28/09/2026, rfc-editor.org/rfc/rfc6902.

What is it?

TheBrain is mind-mapping and personal knowledge management software from TheBrain Technologies, based in Los Angeles. Instead of storing information in folders, it stores thoughts and the links between them, and shows everything in a dynamic graphical interface that blends hierarchy and network. ^{[1] [2]}

Each thought can hold notes, files, web links and calendar events. When you click a thought, it moves to the center of the screen and its neighbors rearrange around it. This layout is called the Plex: ^{[2] [14]}

What sets it apart from an ordinary mind map is that a thought can have several parents. “Bolt M8x30” can sit under “Bolts” and under “Pump assembly kit” at the same time, with no copy. In practice, it is a knowledge graph you draw by hand or through an API. ^{[2] [12]}

The vocabulary we will use: ^{[12] [14]}

Brain

The store holding all the thoughts. Every brain has a starting thought (home).

Thought

The graph node: it has a name and, optionally, a label, type, tags, note and attachments.

Link

The relationship between two thoughts. It can have a name, color and type.

Parent and child

A hierarchical link. A child can have several parents.

Jump

A lateral link with no hierarchy: “is related to”.

Siblings

Thoughts that share a parent. They are not a link of their own.

Type

The main classification: what the thought is. Each thought has at most one type.

Tag

A cross-cutting marker, such as “Critical”. A thought can have several.

Plex

The view with the active thought at the center, surrounded by its neighbors.

How did it start?

The idea was born in 1993 with Harlan Hugh, who felt the need to focus on the connections between pieces of information rather than on the separations. In 1996 he founded Natrificial Software Technologies in California. The company later became The Brain and then TheBrain Technologies, headquartered in Los Angeles, with Hugh still as CEO. ^{[1] [4]}

“Your screen should not look like a bunch of pretty buttons. Instead it should be a dynamic representation and experience of everything that’s important to you.”

Harlan Hugh, to Feed Magazine, 1999 ^[1]

For many years, the personal product was called PersonalBrain. The company also sold enterprise versions, such as TeamBrain and BrainEKP, which won an award in 2008. With version 8, announced on November 20, 2013, the name became simply TheBrain, and syncing across machines moved into a yearly service plan. ^{[2] [3] [5]}

The REST API arrived in November 2023, letting programs read and write thoughts. In 2026, TheBrain 15 brought Cerebro AI, new views (cards, mind map and tree) and the same code on the web, Windows, macOS, iPhone/iPad and Android. It also brought a local API, served by the app itself. The full app became free, and the paid plans kept syncing, AI and collaboration. ^{[6] [7] [8] [10] [11]}

How to install it?

There are two paths. With local, brains live on your machine or in your cluster. With remote, they live in TheBrain’s cloud. The two combine: the desktop can sync with the cloud, and the API works on both sides.

Local: the native app

This is the official path and the simplest one. At thebrain.com/download you will find installers for Windows (.exe, .msi or .zip, Windows 10 or later) and links for Mac, Linux and mobile. No account or credit card is needed. ^[11]

1. Download the installer for your platform.
2. Install and open TheBrain.
3. Create a brain. It starts with a home thought.
4. If you will use the local API, open Settings › User › Local API. The address and the documentation are there. You need version 15.0.534 or later. ^[10]

Local: Docker

TheBrain Technologies does not publish a Docker image, and TheBrain is a desktop app, not a server. Even so, you can containerize two different things, and it pays to keep them apart:

• The desktop itself, inside a Linux desktop reachable from the browser. Here I use the webtop image from LinuxServer.io, which serves XFCE through KasmVNC on port 3001, over HTTPS. ^[17]
• The automation: a container with a script that reads from and writes to the brain through the API. This is the most useful part day to day, and the one we will use in the parts example.

The compose.yaml file

services:
  thebrain:
    image: lscr.io/linuxserver/webtop:ubuntu-xfce
    container_name: thebrain
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Sao_Paulo
      - CUSTOM_USER=giovani
      - PASSWORD=${WEBTOP_PASSWORD}
    volumes:
      - ./thebrain-config:/config
    ports:
      - "127.0.0.1:3001:3001"
    shm_size: "1gb"
    restart: unless-stopped

  importador:
    build: ./importador
    profiles: ["ferramentas"]
    environment:
      - THEBRAIN_API_KEY
      - THEBRAIN_BRAIN_ID
      - THEBRAIN_API_URL=https://api.bra.in
      - PECAS_CSV=/dados/pecas.csv
    volumes:
      - ./dados:/dados:ro

• PUID and PGID set the owner of the files in ./thebrain-config; TZ sets the time zone.
• CUSTOM_USER and PASSWORD turn on basic authentication. The password comes from an environment variable, not from the file.
• The port is published on 127.0.0.1 only. The webtop documentation warns that its terminal grants passwordless sudo and that it should not face the internet without a reverse proxy with strong authentication. ^[17]
• shm_size raises the shared memory that the built-in browser uses.
• The importer lives in the ferramentas (“tools”) profile: it does not start with up, only when called. ^[18]

Starting it and installing TheBrain

read -rs asks for the password without echoing it or saving it in the shell history:

read -rs WEBTOP_PASSWORD && export WEBTOP_PASSWORD
docker compose up -d thebrain

Open https://localhost:3001, accept the self-signed certificate and sign in with the user and password. In the desktop that appears, download the Linux package from thebrain.com/download and install it.

Mind persistence: only /config survives when the container is recreated. If the package extracts into a folder, keep that folder inside /config. If it installs into the system, like a .deb, build a derived image (the file name below is illustrative) and replace image: with build: in the Compose file:

FROM lscr.io/linuxserver/webtop:ubuntu-xfce
COPY thebrain-linux.deb /tmp/
RUN apt-get update \
 && apt-get install -y /tmp/thebrain-linux.deb \
 && rm -rf /tmp/thebrain-linux.deb /var/lib/apt/lists/*

The importer

The importer is the script from the parts section, in a slim Python image:

FROM python:3.12-slim
WORKDIR /app
RUN pip install --no-cache-dir requests
COPY importa_pecas.py .
CMD ["python", "importa_pecas.py"]

read -rs THEBRAIN_API_KEY && export THEBRAIN_API_KEY
export THEBRAIN_BRAIN_ID=00000000-0000-0000-0000-000000000000
docker compose run --rm importador

It talks to the cloud API (api.bra.in), which works with any synced brain. To use the local API instead, set THEBRAIN_API_URL to the address shown in Settings › User › Local API. If it only accepts connections from the same computer, run the script inside the webtop desktop. ^{[10] [12]}

Local: Kubernetes

In Kubernetes, the idea is the same, translated into objects: a Deployment with webtop, a PersistentVolumeClaim for /config, an internal Service and a CronJob that runs the importer every night. The password and the API key live in Secrets. ^{[19] [20] [21] [22]}

apiVersion: v1
kind: Namespace
metadata:
  name: thebrain
---
apiVersion: v1
kind: Secret
metadata:
  name: webtop
  namespace: thebrain
type: Opaque
stringData:
  PASSWORD: "CHANGE-ME"
---
apiVersion: v1
kind: Secret
metadata:
  name: thebrain-api
  namespace: thebrain
type: Opaque
stringData:
  THEBRAIN_API_KEY: "CHANGE-ME"
  THEBRAIN_BRAIN_ID: "00000000-0000-0000-0000-000000000000"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: thebrain-config
  namespace: thebrain
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 10Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: thebrain
  namespace: thebrain
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels: {app: thebrain}
  template:
    metadata:
      labels: {app: thebrain}
    spec:
      containers:
        - name: webtop
          image: lscr.io/linuxserver/webtop:ubuntu-xfce
          env:
            - {name: PUID, value: "1000"}
            - {name: PGID, value: "1000"}
            - {name: TZ, value: America/Sao_Paulo}
            - {name: CUSTOM_USER, value: giovani}
            - name: PASSWORD
              valueFrom:
                secretKeyRef: {name: webtop, key: PASSWORD}
          ports:
            - containerPort: 3001
          resources:
            requests: {cpu: 500m, memory: 2Gi}
            limits: {memory: 4Gi}
          volumeMounts:
            - {name: config, mountPath: /config}
            - {name: shm, mountPath: /dev/shm}
      volumes:
        - name: config
          persistentVolumeClaim: {claimName: thebrain-config}
        - name: shm
          emptyDir: {medium: Memory, sizeLimit: 1Gi}
---
apiVersion: v1
kind: Service
metadata:
  name: thebrain
  namespace: thebrain
spec:
  selector: {app: thebrain}
  ports:
    - {port: 3001, targetPort: 3001}
---
apiVersion: batch/v1
kind: CronJob
metadata:
  name: importa-pecas
  namespace: thebrain
spec:
  schedule: "0 2 * * *"
  timeZone: America/Sao_Paulo
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      backoffLimit: 2
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: importador
              image: registry.exemplo.com/importador-thebrain:1.0
              envFrom:
                - secretRef: {name: thebrain-api}
              env:
                - {name: PECAS_CSV, value: /dados/pecas.csv}
              volumeMounts:
                - {name: dados, mountPath: /dados, readOnly: true}
          volumes:
            - name: dados
              configMap: {name: pecas-csv}

Three choices matter:

• replicas: 1 with strategy: Recreate. The brain is a local app file, not a database with many writers. Two replicas on the same volume would corrupt the data; Recreate makes sure the old pod stops before the new one starts. ^[19]
• /dev/shm as an in-memory emptyDir does the job of Compose’s shm_size.
• The Service is ClusterIP: nothing is exposed. Access goes through port-forward or, if needed, an Ingress with authentication. ^[23]

To apply it, load the CSV, open the desktop and trigger an import without waiting for 2 a.m.:

kubectl apply -f thebrain.yaml
kubectl -n thebrain create configmap pecas-csv --from-file=pecas.csv
kubectl -n thebrain port-forward svc/thebrain 3001:3001
kubectl -n thebrain create job importa-agora --from=cronjob/importa-pecas

Remote

With nothing to install, go to app.thebrain.com and use the web client. Since TheBrain 15, it runs the same code and has the same features as the desktop. To have the same brain on your computer, on the web and on your phone, you need a paid plan, which includes cloud sync. ^{[9] [11]}

To program against the cloud:

1. Generate a key at app.thebrain.com/api-keys.
2. Send it in the Authorization: Bearer <key> header.
3. Browse the interactive documentation at api.bra.in: the Authorize button takes the key, and Try it out runs each call. ^[12]

The first test is to list your brains:

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  https://api.bra.in/brains

For each brain, the response gives the id, the name and the homeThoughtId, which is the home thought. Keep the id: every other call needs it. ^[12]

First steps

1. Create a brain. Every brain starts with a home thought, the root of navigation. In the API, it shows up as homeThoughtId. ^[12]

2. Create thoughts through the gates. Each thought has small circles on its edges, the gates. Each one creates a kind of link: ^[14]

3. Navigate. Click a thought to make it active: the Plex rebuilds around it. To jump straight to a distant thought, search for it by name. ^{[14] [15]}

4. Enrich. Write notes (the API reads and writes them as Markdown), attach files, folders and web addresses, and use the label for a short piece of data, such as a code. ^{[12] [14]}

5. Classify. The type says what the thought is (Part, Material) and can set a color and icon; each thought has at most one. Tags are cross-cutting marks (Critical, Obsolete), and a thought can have several. ^{[12] [14]}

6. Pin what you use all the time. Pinned thoughts stay at hand, whatever the active thought is. ^[12]

7. Switch views. Besides the Plex, TheBrain 15 shows the same brain as cards, a mind map or a tree, without losing a single link. ^[7]

Building an example

The problem: a factory has thousands of parts. Each one belongs to a family (fasteners, bearings, seals), is made of a material, comes from one or more suppliers and follows a standard. Everyday questions cut across these dimensions: “which parts use stainless steel?”, “what do we buy from Alfa Metalworks?”, “which fasteners follow ISO 4017?”.

In a relational database, this becomes tables and foreign keys. In TheBrain, it becomes thoughts and links. This is how they map:

And what TheBrain does not do: enforce integrity (nothing stops a wrong jump), handle transactions or answer aggregate queries, such as total stock per material. So the rule of the example is clear: the ERP remains the owner of the data, and TheBrain is the navigation and knowledge layer, reloaded from an exported file.

Creating a database to classify parts

1. The model

There are five types: Category, Part, Material, Supplier and Standard. The Catalog › category › subcategory › part tree classifies, and jumps tie each part to its material, supplier and standard. Materials, suppliers and standards are also children of three index thoughts (Materials, Suppliers and Standards), attached to the home thought, so you can browse from them.

2. One part by hand

Before automating, build one part in the app to get a feel for the model:

1. Under the home thought, create the child “Parts catalog”; under it, “Fasteners”; and under that, “Bolts”.
2. Under “Bolts”, create “Hex bolt M8x30” and put PAR-M8X30 in the label.
3. Create the Part type and apply it to the thought.
4. Through the side gate, create jumps to “Carbon steel”, “Alfa Metalworks” and “ISO 4017”.
5. Write the data sheet in the note.

3. The input data

The rest comes from an ERP export, simplified here into a semicolon-separated CSV. The suppliers are fictitious; the standards are real: ISO 4017 (hex head screws), ISO 4032 (hex nuts), ISO 7089 (plain washers), ISO 15 (radial bearing dimensions) and ISO 3601-1 (O-rings).

codigo;descricao;categoria;subcategoria;material;fornecedor;norma;estoque
PAR-M8X30;Parafuso sextavado M8x30;Fixadores;Parafusos;Aço carbono;Metalúrgica Alfa;ISO 4017;1200
PAR-M6X20;Parafuso sextavado M6x20;Fixadores;Parafusos;Aço inox A2-70;Metalúrgica Alfa;ISO 4017;850
POR-M8;Porca sextavada M8;Fixadores;Porcas;Aço carbono;Metalúrgica Alfa;ISO 4032;3000
ARR-8;Arruela lisa 8 mm;Fixadores;Arruelas;Aço carbono;Metalúrgica Alfa;ISO 7089;5000
ROL-6204;Rolamento de esferas 6204-2RS;Transmissão;Rolamentos;Aço cromo;Rolamentos Beta;ISO 15;80
VED-OR20;Anel O-ring 20x2 NBR 70;Vedação;Anéis O-ring;Borracha NBR;Vedações Gama;ISO 3601-1;400

4. The import script

The script uses only the requests library and six API endpoints. It is idempotent: before creating a thought, it looks it up by exact name; before linking two, it checks whether the link already exists. It can run every night without duplicating anything. ^{[12] [13]}

"""Carrega pecas.csv num cérebro do TheBrain usando a API REST."""
import csv
import os

import requests

API = os.environ.get("THEBRAIN_API_URL", "https://api.bra.in").rstrip("/")
BRAIN = os.environ["THEBRAIN_BRAIN_ID"]
CSV = os.environ.get("PECAS_CSV", "pecas.csv")
S = requests.Session()
S.headers["Authorization"] = "Bearer " + os.environ["THEBRAIN_API_KEY"]

NORMAL, TIPO = 1, 2            # kind
FILHO, PAI, SALTO = 1, 2, 3    # relation
PRIVADO = 1                    # acType
ids = {}


def vazio(r):
    return not r.ok or r.text.strip() in ("", "null")


def buscar(nome):
    if nome not in ids:
        r = S.get(f"{API}/thoughts/{BRAIN}", params={"nameExact": nome})
        ids[nome] = None if vazio(r) else r.json()["id"]
    return ids[nome]


def ligar(a, b, relacao):
    if not vazio(S.get(f"{API}/links/{BRAIN}/{a}/{b}")):
        return  # já estão ligados
    corpo = {"thoughtIdA": a, "thoughtIdB": b, "relation": relacao}
    S.post(f"{API}/links/{BRAIN}", json=corpo).raise_for_status()


def garantir(nome, origem=None, relacao=FILHO, tipo=None, rotulo=None, kind=NORMAL):
    tid = buscar(nome)
    if tid:
        if origem:
            ligar(origem, tid, relacao)
        return tid
    corpo = {"name": nome, "kind": kind, "acType": PRIVADO}
    if origem:
        corpo.update(sourceThoughtId=origem, relation=relacao)
    if tipo:
        corpo["typeId"] = tipo
    if rotulo:
        corpo["label"] = rotulo
    r = S.post(f"{API}/thoughts/{BRAIN}", json=corpo)
    r.raise_for_status()
    ids[nome] = r.json()["id"]
    return ids[nome]


home = S.get(f"{API}/brains/{BRAIN}").json()["homeThoughtId"]
tipos = {t: garantir(t, kind=TIPO)
         for t in ("Peça", "Categoria", "Material", "Fornecedor", "Norma")}
catalogo = garantir("Catálogo de peças", home)
hubs = {h: garantir(h, home) for h in ("Materiais", "Fornecedores", "Normas")}
jumps = (("material", "Material", "Materiais"),
         ("fornecedor", "Fornecedor", "Fornecedores"),
         ("norma", "Norma", "Normas"))

with open(CSV, encoding="utf-8") as f:
    for p in csv.DictReader(f, delimiter=";"):
        cat = garantir(p["categoria"], catalogo, tipo=tipos["Categoria"])
        sub = garantir(p["subcategoria"], cat, tipo=tipos["Categoria"])
        peca = garantir(p["descricao"], sub, tipo=tipos["Peça"], rotulo=p["codigo"])
        for coluna, tipo, hub in jumps:
            alvo = garantir(p[coluna], hubs[hub], tipo=tipos[tipo])
            ligar(peca, alvo, SALTO)
        nota = ("| Campo | Valor |\n|---|---|\n"
                f"| Código | {p['codigo']} |\n"
                f"| Estoque | {p['estoque']} un. |\n")
        S.post(f"{API}/notes/{BRAIN}/{peca}/update",
               json={"markdown": nota}).raise_for_status()
        print("ok:", p["codigo"], "-", p["descricao"])

The numbers in the script come from the API specification: ^[12]

5. Running it

python -m pip install requests
read -rs THEBRAIN_API_KEY && export THEBRAIN_API_KEY
export THEBRAIN_BRAIN_ID=00000000-0000-0000-0000-000000000000
python importa_pecas.py

ok: PAR-M8X30 - Parafuso sextavado M8x30
ok: PAR-M6X20 - Parafuso sextavado M6x20
ok: POR-M8 - Porca sextavada M8
ok: ARR-8 - Arruela lisa 8 mm
ok: ROL-6204 - Rolamento de esferas 6204-2RS
ok: VED-OR20 - Anel O-ring 20x2 NBR 70

6. Querying

In the app, click “Carbon steel”: the jumps show every part made of it. Click “Alfa Metalworks”: everything it supplies appears. It is the visual equivalent of a JOIN. Through the API, text search and a thought’s neighborhood play the same role:

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  "https://api.bra.in/search/$THEBRAIN_BRAIN_ID?queryText=M8&maxResults=30"

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  "https://api.bra.in/thoughts/$THEBRAIN_BRAIN_ID/$MATERIAL_ID/graph"

The /graph response separates parents, children, jumps, siblings, tags and links. The parts that use the material come in jumps. ^[12]

7. Next steps

• Mark parts with the tags “Critical” or “Obsolete”.
• Create kits: a “Pump assembly kit” thought as an extra parent of the parts it contains.
• Attach PDF drawings with POST /attachments/{brainId}/{thoughtId}/file.
• Update names, labels and colors with PATCH, which follows the JSON Patch format. ^{[12] [24]}

Conclusions

• At heart, TheBrain is a knowledge graph with a very good interface for browsing it. It shines when relationships matter more than columns.
• Installing is simple on the desktop and on the web. Docker and Kubernetes are possible but not official: they serve to host the desktop on a server and, above all, to automate data loading through the API.
• The REST API, in the cloud or local, turns TheBrain into an integration target. The example loads a parts database from a CSV without duplicating anything.
• It does not replace the relational database or the ERP: it has no integrity, transactions or aggregations. Use it as a navigation and documentation layer, fed by the system that owns the data.
• For questions, the best sources are the interactive API documentation, the user guide and the official forum. ^{[12] [14] [16]}

References

1. TheBrain Technologies, “About TheBrain”, accessed 28 September 2026, thebrain.com/about.
2. Wikipedia, “TheBrain”, accessed 28 September 2026, en.wikipedia.org/wiki/TheBrain.
3. Wikipedia, “TheBrain Technologies”, accessed 28 September 2026, en.wikipedia.org/wiki/TheBrain_Technologies.
4. Computerworld, “Linking Your Thinking”, 31 January 2000, accessed 28 September 2026, computerworld.com/article/1368716/linking-your-thinking.html.
5. PRWeb, “TheBrain 8 Delivers Advanced Information Management with Powerful New Knowledge Visualization Features”, 20 November 2013, accessed 28 September 2026, prweb.com/releases/thebrain_8_delivers_advanced_information_management_with_powerful_new_knowledge_visualization_features/prweb11352059.htm.
6. TheBrain Blog, “Introducing TheBrain API”, 1 November 2023, accessed 28 September 2026, thebrain.com/blog/introducing-thebrain-api.
7. TheBrain Technologies, “TheBrain 15 — Beyond next-gen, with Cerebro AI”, accessed 28 September 2026, thebrain.com/products/thebrain/thebrain15.
8. TheBrain Blog, “TheBrain 15 Achieves True Cross-Platform Parity: One Codebase, Five Platforms, Full Feature Equality”, 24 April 2026, accessed 28 September 2026, old.thebrain.com/blog/true-cross-platform-parity.
9. TheBrain Blog, “Unifying TheBrain: Version 15 Now Live on the Web”, accessed 28 September 2026, thebrain.com/blog/unifying-thebrain.
10. TheBrain Blog, “TheBrain API: Now Fully Local and Unrestrained”, 28 April 2026, accessed 28 September 2026, thebrain.com/blog/thebrain-api-local.
11. TheBrain Technologies, “Download TheBrain — Free, forever”, accessed 28 September 2026, thebrain.com/download.
12. TheBrain Technologies, TheBrain API, interactive documentation, version 1.0.5, accessed 28 September 2026, api.bra.in.
13. TheBrainTech, “thebrain-api-quickstart-python”, GitHub, accessed 28 September 2026, github.com/TheBrainTech/thebrain-api-quickstart-python.
14. TheBrain Technologies, TheBrain 14 User Guide (PDF), accessed 28 September 2026, assets.thebrain.com/documents/TheBrain14/TheBrain14-User-Guide-v01.pdf.
15. TheBrain Technologies, “Tutorials”, accessed 28 September 2026, thebrain.com/tutorials.
16. TheBrain Forums, official forum, accessed 28 September 2026, forums.thebrain.com.
17. LinuxServer.io, “webtop”, accessed 28 September 2026, docs.linuxserver.io/images/docker-webtop.
18. Docker, “Compose file reference”, accessed 28 September 2026, docs.docker.com/reference/compose-file.
19. Kubernetes, “Deployments”, accessed 28 September 2026, kubernetes.io/docs/concepts/workloads/controllers/deployment.
20. Kubernetes, “Persistent Volumes”, accessed 28 September 2026, kubernetes.io/docs/concepts/storage/persistent-volumes.
21. Kubernetes, “CronJob”, accessed 28 September 2026, kubernetes.io/docs/concepts/workloads/controllers/cron-job.
22. Kubernetes, “Secrets”, accessed 28 September 2026, kubernetes.io/docs/concepts/configuration/secret.
23. Kubernetes, “Use Port Forwarding to Access Applications in a Cluster”, accessed 28 September 2026, kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster.
24. IETF, RFC 6902, “JavaScript Object Notation (JSON) Patch”, 2013, accessed 28 September 2026, rfc-editor.org/rfc/rfc6902.

Che cos’è?

TheBrain è un software di mappe mentali e di gestione della conoscenza personale di TheBrain Technologies, con sede a Los Angeles. Invece di conservare le informazioni in cartelle, conserva pensieri (thoughts) e i collegamenti tra di essi, e mostra tutto in un’interfaccia grafica dinamica che unisce gerarchia e rete. ^{[1] [2]}

Ogni pensiero può contenere note, file, link web ed eventi di calendario. Quando clicchi su un pensiero, questo si sposta al centro dello schermo e i vicini si riorganizzano intorno. Questa disposizione si chiama Plex: ^{[2] [14]}

La differenza rispetto a una normale mappa mentale è che un pensiero può avere più genitori. “Vite M8x30” può stare contemporaneamente sotto “Viti” e sotto “Kit di montaggio della pompa”, senza copie. In pratica è un grafo della conoscenza che disegni a mano o tramite API. ^{[2] [12]}

Il vocabolario che useremo: ^{[12] [14]}

Cervello (brain)

La base che contiene tutti i pensieri. Ogni cervello ha un pensiero iniziale (home).

Pensiero (thought)

Il nodo del grafo: ha un nome e, facoltativamente, etichetta, tipo, tag, nota e allegati.

Collegamento (link)

La relazione tra due pensieri. Può avere nome, colore e tipo.

Genitore e figlio

Collegamento gerarchico. Un figlio può avere più genitori.

Salto (jump)

Collegamento laterale, senza gerarchia: “è correlato a”.

Fratelli (siblings)

Pensieri con lo stesso genitore. Non sono un collegamento a sé.

Tipo (type)

La classificazione principale: che cosa è il pensiero. Ogni pensiero ha al massimo un tipo.

Tag

Un contrassegno trasversale, come “Critico”. Un pensiero può averne diversi.

Plex

La vista con il pensiero attivo al centro, circondato dai vicini.

Come è nato?

L’idea nasce nel 1993 con Harlan Hugh, che sentiva il bisogno di concentrarsi sulle connessioni tra le informazioni, e non sulle separazioni. Nel 1996 fondò la Natrificial Software Technologies, in California. L’azienda prese poi il nome di The Brain e, più tardi, di TheBrain Technologies, con sede a Los Angeles e con Hugh ancora CEO. ^{[1] [4]}

“Il tuo schermo non dovrebbe sembrare un mucchio di bei pulsanti. Dovrebbe essere una rappresentazione dinamica, un’esperienza, di tutto ciò che è importante per te.”

Harlan Hugh, alla rivista Feed, 1999 ^[1]

Per molti anni il prodotto per uso personale si è chiamato PersonalBrain. L’azienda ha venduto anche versioni aziendali, come TeamBrain e BrainEKP, premiato nel 2008. Con la versione 8, annunciata il 20 novembre 2013, il nome è diventato semplicemente TheBrain, e la sincronizzazione tra computer è entrata in un piano di servizio annuale. ^{[2] [3] [5]}

A novembre 2023 è arrivata l’API REST, che permette di leggere e scrivere pensieri da programma. Nel 2026 TheBrain 15 ha portato l’IA Cerebro, nuove viste (schede, mappa mentale e albero) e lo stesso codice su web, Windows, macOS, iPhone/iPad e Android. Ha portato anche un’API locale, servita dall’app stessa. L’app completa è diventata gratuita, e i piani a pagamento hanno mantenuto sincronizzazione, IA e collaborazione. ^{[6] [7] [8] [10] [11]}

Come installarlo?

Ci sono due strade. In locale, i cervelli restano sulla tua macchina o nel tuo cluster. In remoto, restano nel cloud di TheBrain. Le due si combinano: il desktop può sincronizzarsi con il cloud, e l’API funziona da entrambe le parti.

Locale: l’app nativa

È la strada ufficiale e la più semplice. Su thebrain.com/download ci sono gli installer per Windows (.exe, .msi o .zip, da Windows 10 in poi) e i link per Mac, Linux e dispositivi mobili. Non servono account né carta di credito. ^[11]

1. Scarica l’installer della tua piattaforma.
2. Installa e apri TheBrain.
3. Crea un cervello. Nasce con un pensiero iniziale.
4. Se userai l’API locale, apri Impostazioni › Utente › API locale. Lì trovi l’indirizzo e la documentazione. Serve la versione 15.0.534 o successiva. ^[10]

Locale: Docker

TheBrain Technologies non pubblica un’immagine Docker, e TheBrain è un’app desktop, non un server. Anche così, si possono mettere in container due cose diverse, ed è bene tenerle separate:

• Il desktop stesso, dentro un desktop Linux raggiungibile dal browser. Qui uso l’immagine webtop di LinuxServer.io, che offre XFCE tramite KasmVNC sulla porta 3001, in HTTPS. ^[17]
• L’automazione: un container con uno script che legge e scrive nel cervello tramite l’API. È la parte più utile nel lavoro quotidiano, ed è quella che useremo nell’esempio dei pezzi.

Il file compose.yaml

services:
  thebrain:
    image: lscr.io/linuxserver/webtop:ubuntu-xfce
    container_name: thebrain
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Sao_Paulo
      - CUSTOM_USER=giovani
      - PASSWORD=${WEBTOP_PASSWORD}
    volumes:
      - ./thebrain-config:/config
    ports:
      - "127.0.0.1:3001:3001"
    shm_size: "1gb"
    restart: unless-stopped

  importador:
    build: ./importador
    profiles: ["ferramentas"]
    environment:
      - THEBRAIN_API_KEY
      - THEBRAIN_BRAIN_ID
      - THEBRAIN_API_URL=https://api.bra.in
      - PECAS_CSV=/dados/pecas.csv
    volumes:
      - ./dados:/dados:ro

• PUID e PGID definiscono il proprietario dei file in ./thebrain-config; TZ, il fuso orario.
• CUSTOM_USER e PASSWORD attivano l’autenticazione di base. La password arriva da una variabile d’ambiente, non dal file.
• La porta è pubblicata solo su 127.0.0.1. La documentazione di webtop avverte che il suo terminale concede sudo senza password e che non va esposto su internet senza un reverse proxy con autenticazione forte. ^[17]
• shm_size aumenta la memoria condivisa, usata dal browser interno.
• L’importatore sta nel profilo ferramentas (“strumenti”): non parte con up, solo quando viene chiamato. ^[18]

Avvio e installazione di TheBrain

read -rs chiede la password senza mostrarla e senza salvarla nella cronologia della shell:

read -rs WEBTOP_PASSWORD && export WEBTOP_PASSWORD
docker compose up -d thebrain

Apri https://localhost:3001, accetta il certificato autofirmato ed entra con utente e password. Nel desktop che compare, scarica il pacchetto Linux da thebrain.com/download e installalo.

Attenzione alla persistenza: solo /config sopravvive quando il container viene ricreato. Se il pacchetto si estrae in una cartella, tienila dentro /config. Se si installa nel sistema, come un .deb, crea un’immagine derivata (il nome del file qui sotto è indicativo) e sostituisci image: con build: nel Compose:

FROM lscr.io/linuxserver/webtop:ubuntu-xfce
COPY thebrain-linux.deb /tmp/
RUN apt-get update \
 && apt-get install -y /tmp/thebrain-linux.deb \
 && rm -rf /tmp/thebrain-linux.deb /var/lib/apt/lists/*

L’importatore

L’importatore è lo script della sezione sui pezzi, in un’immagine Python snella:

FROM python:3.12-slim
WORKDIR /app
RUN pip install --no-cache-dir requests
COPY importa_pecas.py .
CMD ["python", "importa_pecas.py"]

read -rs THEBRAIN_API_KEY && export THEBRAIN_API_KEY
export THEBRAIN_BRAIN_ID=00000000-0000-0000-0000-000000000000
docker compose run --rm importador

Parla con l’API cloud (api.bra.in), che funziona con qualsiasi cervello sincronizzato. Per usare l’API locale, imposta THEBRAIN_API_URL sull’indirizzo mostrato in Impostazioni › Utente › API locale. Se accetta solo connessioni dallo stesso computer, esegui lo script dentro il desktop di webtop. ^{[10] [12]}

Locale: Kubernetes

In Kubernetes l’idea è la stessa, tradotta in oggetti: un Deployment con webtop, un PersistentVolumeClaim per /config, un Service interno e un CronJob che esegue l’importatore ogni notte. La password e la chiave dell’API stanno nei Secret. ^{[19] [20] [21] [22]}

apiVersion: v1
kind: Namespace
metadata:
  name: thebrain
---
apiVersion: v1
kind: Secret
metadata:
  name: webtop
  namespace: thebrain
type: Opaque
stringData:
  PASSWORD: "CHANGE-ME"
---
apiVersion: v1
kind: Secret
metadata:
  name: thebrain-api
  namespace: thebrain
type: Opaque
stringData:
  THEBRAIN_API_KEY: "CHANGE-ME"
  THEBRAIN_BRAIN_ID: "00000000-0000-0000-0000-000000000000"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: thebrain-config
  namespace: thebrain
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 10Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: thebrain
  namespace: thebrain
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels: {app: thebrain}
  template:
    metadata:
      labels: {app: thebrain}
    spec:
      containers:
        - name: webtop
          image: lscr.io/linuxserver/webtop:ubuntu-xfce
          env:
            - {name: PUID, value: "1000"}
            - {name: PGID, value: "1000"}
            - {name: TZ, value: America/Sao_Paulo}
            - {name: CUSTOM_USER, value: giovani}
            - name: PASSWORD
              valueFrom:
                secretKeyRef: {name: webtop, key: PASSWORD}
          ports:
            - containerPort: 3001
          resources:
            requests: {cpu: 500m, memory: 2Gi}
            limits: {memory: 4Gi}
          volumeMounts:
            - {name: config, mountPath: /config}
            - {name: shm, mountPath: /dev/shm}
      volumes:
        - name: config
          persistentVolumeClaim: {claimName: thebrain-config}
        - name: shm
          emptyDir: {medium: Memory, sizeLimit: 1Gi}
---
apiVersion: v1
kind: Service
metadata:
  name: thebrain
  namespace: thebrain
spec:
  selector: {app: thebrain}
  ports:
    - {port: 3001, targetPort: 3001}
---
apiVersion: batch/v1
kind: CronJob
metadata:
  name: importa-pecas
  namespace: thebrain
spec:
  schedule: "0 2 * * *"
  timeZone: America/Sao_Paulo
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      backoffLimit: 2
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: importador
              image: registry.exemplo.com/importador-thebrain:1.0
              envFrom:
                - secretRef: {name: thebrain-api}
              env:
                - {name: PECAS_CSV, value: /dados/pecas.csv}
              volumeMounts:
                - {name: dados, mountPath: /dados, readOnly: true}
          volumes:
            - name: dados
              configMap: {name: pecas-csv}

Tre scelte contano:

• replicas: 1 con strategy: Recreate. Il cervello è un file locale dell’app, non un database con più scrittori. Due repliche sullo stesso volume corromperebbero i dati; Recreate garantisce che il pod vecchio si fermi prima che parta quello nuovo. ^[19]
• /dev/shm come emptyDir in memoria fa le veci dello shm_size del Compose.
• Il Service è ClusterIP: niente è esposto. Si accede con port-forward o, se serve, con un Ingress con autenticazione. ^[23]

Per applicare, caricare il CSV, aprire il desktop e lanciare un’importazione senza aspettare le 2 di notte:

kubectl apply -f thebrain.yaml
kubectl -n thebrain create configmap pecas-csv --from-file=pecas.csv
kubectl -n thebrain port-forward svc/thebrain 3001:3001
kubectl -n thebrain create job importa-agora --from=cronjob/importa-pecas

Remoto

Senza installare nulla, vai su app.thebrain.com e usa il client web. Da TheBrain 15 ha lo stesso codice e le stesse funzioni del desktop. Per avere lo stesso cervello sul computer, sul web e sul telefono serve un piano a pagamento, che include la sincronizzazione cloud. ^{[9] [11]}

Per programmare contro il cloud:

1. Genera una chiave su app.thebrain.com/api-keys.
2. Inviala nell’intestazione Authorization: Bearer <chiave>.
3. Consulta la documentazione interattiva su api.bra.in: il pulsante Authorize riceve la chiave, e Try it out esegue ogni chiamata. ^[12]

Il primo test è elencare i tuoi cervelli:

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  https://api.bra.in/brains

Per ogni cervello, la risposta riporta l’id, il name e l’homeThoughtId, cioè il pensiero iniziale. Conserva l’id: serve in tutte le altre chiamate. ^[12]

I primi passi

1. Crea un cervello. Ogni cervello nasce con un pensiero iniziale, la radice della navigazione. Nell’API compare come homeThoughtId. ^[12]

2. Crea pensieri dalle porte. Ogni pensiero ha piccoli cerchi sui bordi, le porte. Ognuna crea un tipo di collegamento: ^[14]

3. Naviga. Clicca su un pensiero per renderlo attivo: il Plex si ricostruisce intorno a lui. Per andare dritto a un pensiero lontano, cercalo per nome. ^{[14] [15]}

4. Arricchisci. Scrivi note (l’API le legge e le scrive in Markdown), allega file, cartelle e indirizzi web, e usa l’etichetta per un dato breve, come un codice. ^{[12] [14]}

5. Classifica. Il tipo dice che cosa è il pensiero (Pezzo, Materiale) e può definire colore e icona; ogni pensiero ne ha al massimo uno. I tag sono contrassegni trasversali (Critico, Obsoleto), e un pensiero può averne diversi. ^{[12] [14]}

6. Fissa ciò che usi sempre. I pensieri fissati (pins) restano sempre a portata di mano, qualunque sia il pensiero attivo. ^[12]

7. Cambia vista. Oltre al Plex, TheBrain 15 mostra lo stesso cervello come schede, mappa mentale o albero, senza perdere nessun collegamento. ^[7]

Costruire un esempio

Il problema: una fabbrica ha migliaia di pezzi. Ognuno appartiene a una famiglia (elementi di fissaggio, cuscinetti, tenute), è fatto di un materiale, arriva da uno o più fornitori e segue una norma. Le domande di tutti i giorni incrociano queste dimensioni: “quali pezzi usano acciaio inox?”, “che cosa compriamo dalla Metallurgica Alfa?”, “quali elementi di fissaggio seguono la ISO 4017?”.

In un database relazionale, questo diventa tabelle e chiavi esterne. In TheBrain, diventa pensieri e collegamenti. La corrispondenza è questa:

E ciò che TheBrain non fa: garantire l’integrità (niente impedisce un salto sbagliato), gestire le transazioni o rispondere a query aggregate, come la somma delle scorte per materiale. Perciò la regola dell’esempio è chiara: l’ERP resta il proprietario dei dati, e TheBrain è lo strato di navigazione e di conoscenza, ricaricato da un file esportato.

Creare un database per classificare i pezzi

1. Il modello

Ci sono cinque tipi: Categoria, Pezzo, Materiale, Fornitore e Norma. L’albero Catalogo › categoria › sottocategoria › pezzo classifica, e i salti legano ogni pezzo al materiale, al fornitore e alla norma. Materiali, fornitori e norme sono anche figli di tre pensieri indice (Materiali, Fornitori e Norme), attaccati al pensiero iniziale, così puoi navigare anche a partire da loro.

2. Un pezzo fatto a mano

Prima di automatizzare, costruisci un pezzo nell’app per prendere confidenza con il modello:

1. Sotto il pensiero iniziale, crea il figlio “Catalogo dei pezzi”; sotto di esso, “Elementi di fissaggio”; e sotto questo, “Viti”.
2. Sotto “Viti”, crea “Vite a testa esagonale M8x30” e metti PAR-M8X30 nell’etichetta.
3. Crea il tipo Pezzo e applicalo al pensiero.
4. Dalla porta laterale, crea i salti verso “Acciaio al carbonio”, “Metallurgica Alfa” e “ISO 4017”.
5. Scrivi la scheda tecnica nella nota.

3. I dati di input

Il resto arriva da un’esportazione dell’ERP, qui semplificata in un CSV separato da punto e virgola. I fornitori sono fittizi; le norme sono reali: ISO 4017 (viti a testa esagonale), ISO 4032 (dadi esagonali), ISO 7089 (rondelle piane), ISO 15 (dimensioni dei cuscinetti radiali) e ISO 3601-1 (O-ring).

codigo;descricao;categoria;subcategoria;material;fornecedor;norma;estoque
PAR-M8X30;Parafuso sextavado M8x30;Fixadores;Parafusos;Aço carbono;Metalúrgica Alfa;ISO 4017;1200
PAR-M6X20;Parafuso sextavado M6x20;Fixadores;Parafusos;Aço inox A2-70;Metalúrgica Alfa;ISO 4017;850
POR-M8;Porca sextavada M8;Fixadores;Porcas;Aço carbono;Metalúrgica Alfa;ISO 4032;3000
ARR-8;Arruela lisa 8 mm;Fixadores;Arruelas;Aço carbono;Metalúrgica Alfa;ISO 7089;5000
ROL-6204;Rolamento de esferas 6204-2RS;Transmissão;Rolamentos;Aço cromo;Rolamentos Beta;ISO 15;80
VED-OR20;Anel O-ring 20x2 NBR 70;Vedação;Anéis O-ring;Borracha NBR;Vedações Gama;ISO 3601-1;400

4. Lo script di importazione

Lo script usa solo la libreria requests e sei endpoint dell’API. È idempotente: prima di creare un pensiero, lo cerca per nome esatto; prima di collegarne due, verifica se il collegamento esiste già. Può girare ogni notte senza duplicare nulla. ^{[12] [13]}

"""Carrega pecas.csv num cérebro do TheBrain usando a API REST."""
import csv
import os

import requests

API = os.environ.get("THEBRAIN_API_URL", "https://api.bra.in").rstrip("/")
BRAIN = os.environ["THEBRAIN_BRAIN_ID"]
CSV = os.environ.get("PECAS_CSV", "pecas.csv")
S = requests.Session()
S.headers["Authorization"] = "Bearer " + os.environ["THEBRAIN_API_KEY"]

NORMAL, TIPO = 1, 2            # kind
FILHO, PAI, SALTO = 1, 2, 3    # relation
PRIVADO = 1                    # acType
ids = {}


def vazio(r):
    return not r.ok or r.text.strip() in ("", "null")


def buscar(nome):
    if nome not in ids:
        r = S.get(f"{API}/thoughts/{BRAIN}", params={"nameExact": nome})
        ids[nome] = None if vazio(r) else r.json()["id"]
    return ids[nome]


def ligar(a, b, relacao):
    if not vazio(S.get(f"{API}/links/{BRAIN}/{a}/{b}")):
        return  # já estão ligados
    corpo = {"thoughtIdA": a, "thoughtIdB": b, "relation": relacao}
    S.post(f"{API}/links/{BRAIN}", json=corpo).raise_for_status()


def garantir(nome, origem=None, relacao=FILHO, tipo=None, rotulo=None, kind=NORMAL):
    tid = buscar(nome)
    if tid:
        if origem:
            ligar(origem, tid, relacao)
        return tid
    corpo = {"name": nome, "kind": kind, "acType": PRIVADO}
    if origem:
        corpo.update(sourceThoughtId=origem, relation=relacao)
    if tipo:
        corpo["typeId"] = tipo
    if rotulo:
        corpo["label"] = rotulo
    r = S.post(f"{API}/thoughts/{BRAIN}", json=corpo)
    r.raise_for_status()
    ids[nome] = r.json()["id"]
    return ids[nome]


home = S.get(f"{API}/brains/{BRAIN}").json()["homeThoughtId"]
tipos = {t: garantir(t, kind=TIPO)
         for t in ("Peça", "Categoria", "Material", "Fornecedor", "Norma")}
catalogo = garantir("Catálogo de peças", home)
hubs = {h: garantir(h, home) for h in ("Materiais", "Fornecedores", "Normas")}
jumps = (("material", "Material", "Materiais"),
         ("fornecedor", "Fornecedor", "Fornecedores"),
         ("norma", "Norma", "Normas"))

with open(CSV, encoding="utf-8") as f:
    for p in csv.DictReader(f, delimiter=";"):
        cat = garantir(p["categoria"], catalogo, tipo=tipos["Categoria"])
        sub = garantir(p["subcategoria"], cat, tipo=tipos["Categoria"])
        peca = garantir(p["descricao"], sub, tipo=tipos["Peça"], rotulo=p["codigo"])
        for coluna, tipo, hub in jumps:
            alvo = garantir(p[coluna], hubs[hub], tipo=tipos[tipo])
            ligar(peca, alvo, SALTO)
        nota = ("| Campo | Valor |\n|---|---|\n"
                f"| Código | {p['codigo']} |\n"
                f"| Estoque | {p['estoque']} un. |\n")
        S.post(f"{API}/notes/{BRAIN}/{peca}/update",
               json={"markdown": nota}).raise_for_status()
        print("ok:", p["codigo"], "-", p["descricao"])

I numeri dello script vengono dalla specifica dell’API: ^[12]

5. Esecuzione

python -m pip install requests
read -rs THEBRAIN_API_KEY && export THEBRAIN_API_KEY
export THEBRAIN_BRAIN_ID=00000000-0000-0000-0000-000000000000
python importa_pecas.py

ok: PAR-M8X30 - Parafuso sextavado M8x30
ok: PAR-M6X20 - Parafuso sextavado M6x20
ok: POR-M8 - Porca sextavada M8
ok: ARR-8 - Arruela lisa 8 mm
ok: ROL-6204 - Rolamento de esferas 6204-2RS
ok: VED-OR20 - Anel O-ring 20x2 NBR 70

6. Interrogare

Nell’app, clicca su “Acciaio al carbonio”: i salti mostrano tutti i pezzi fatti con quel materiale. Clicca su “Metallurgica Alfa”: compare tutto ciò che fornisce. È l’equivalente visivo di una JOIN. Dall’API, la ricerca testuale e il vicinato di un pensiero svolgono lo stesso ruolo:

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  "https://api.bra.in/search/$THEBRAIN_BRAIN_ID?queryText=M8&maxResults=30"

curl -s -H "Authorization: Bearer $THEBRAIN_API_KEY" \
  "https://api.bra.in/thoughts/$THEBRAIN_BRAIN_ID/$MATERIAL_ID/graph"

La risposta di /graph separa parents, children, jumps, siblings, tags e links. I pezzi che usano il materiale arrivano in jumps. ^[12]

7. Prossimi passi

• Contrassegna i pezzi con i tag “Critico” o “Obsoleto”.
• Crea kit: un pensiero “Kit di montaggio della pompa” come genitore aggiuntivo dei pezzi che lo compongono.
• Allega disegni in PDF con POST /attachments/{brainId}/{thoughtId}/file.
• Aggiorna nomi, etichette e colori con PATCH, che segue il formato JSON Patch. ^{[12] [24]}

Conclusioni

• In fondo, TheBrain è un grafo della conoscenza con un’ottima interfaccia per navigarlo. Dà il meglio quando le relazioni contano più delle colonne.
• Installarlo è semplice sul desktop e sul web. Docker e Kubernetes sono possibili ma non ufficiali: servono a ospitare il desktop su un server e, soprattutto, ad automatizzare il caricamento dei dati tramite l’API.
• L’API REST, nel cloud o locale, fa di TheBrain una destinazione di integrazione. L’esempio carica un database di pezzi da un CSV senza duplicare nulla.
• Non sostituisce il database relazionale né l’ERP: non ha integrità, transazioni né aggregazioni. Usalo come strato di navigazione e documentazione, alimentato dal sistema proprietario dei dati.
• Per i dubbi, le fonti migliori sono la documentazione interattiva dell’API, la guida utente e il forum ufficiale. ^{[12] [14] [16]}

Riferimenti

1. TheBrain Technologies, “About TheBrain”, consultato il 28/09/2026, thebrain.com/about.
2. Wikipedia (in inglese), “TheBrain”, consultato il 28/09/2026, en.wikipedia.org/wiki/TheBrain.
3. Wikipedia (in inglese), “TheBrain Technologies”, consultato il 28/09/2026, en.wikipedia.org/wiki/TheBrain_Technologies.
4. Computerworld, “Linking Your Thinking”, 31/01/2000, consultato il 28/09/2026, computerworld.com/article/1368716/linking-your-thinking.html.
5. PRWeb, “TheBrain 8 Delivers Advanced Information Management with Powerful New Knowledge Visualization Features”, 20/11/2013, consultato il 28/09/2026, prweb.com/releases/thebrain_8_delivers_advanced_information_management_with_powerful_new_knowledge_visualization_features/prweb11352059.htm.
6. TheBrain Blog, “Introducing TheBrain API”, 01/11/2023, consultato il 28/09/2026, thebrain.com/blog/introducing-thebrain-api.
7. TheBrain Technologies, “TheBrain 15 — Beyond next-gen, with Cerebro AI”, consultato il 28/09/2026, thebrain.com/products/thebrain/thebrain15.
8. TheBrain Blog, “TheBrain 15 Achieves True Cross-Platform Parity: One Codebase, Five Platforms, Full Feature Equality”, 24/04/2026, consultato il 28/09/2026, old.thebrain.com/blog/true-cross-platform-parity.
9. TheBrain Blog, “Unifying TheBrain: Version 15 Now Live on the Web”, consultato il 28/09/2026, thebrain.com/blog/unifying-thebrain.
10. TheBrain Blog, “TheBrain API: Now Fully Local and Unrestrained”, 28/04/2026, consultato il 28/09/2026, thebrain.com/blog/thebrain-api-local.
11. TheBrain Technologies, “Download TheBrain — Free, forever”, consultato il 28/09/2026, thebrain.com/download.
12. TheBrain Technologies, TheBrain API, documentazione interattiva, versione 1.0.5, consultato il 28/09/2026, api.bra.in.
13. TheBrainTech, “thebrain-api-quickstart-python”, GitHub, consultato il 28/09/2026, github.com/TheBrainTech/thebrain-api-quickstart-python.
14. TheBrain Technologies, TheBrain 14 User Guide (PDF), consultato il 28/09/2026, assets.thebrain.com/documents/TheBrain14/TheBrain14-User-Guide-v01.pdf.
15. TheBrain Technologies, “Tutorials”, consultato il 28/09/2026, thebrain.com/tutorials.
16. TheBrain Forums, forum ufficiale, consultato il 28/09/2026, forums.thebrain.com.
17. LinuxServer.io, “webtop”, consultato il 28/09/2026, docs.linuxserver.io/images/docker-webtop.
18. Docker, “Compose file reference”, consultato il 28/09/2026, docs.docker.com/reference/compose-file.
19. Kubernetes, “Deployments”, consultato il 28/09/2026, kubernetes.io/docs/concepts/workloads/controllers/deployment.
20. Kubernetes, “Persistent Volumes”, consultato il 28/09/2026, kubernetes.io/docs/concepts/storage/persistent-volumes.
21. Kubernetes, “CronJob”, consultato il 28/09/2026, kubernetes.io/docs/concepts/workloads/controllers/cron-job.
22. Kubernetes, “Secrets”, consultato il 28/09/2026, kubernetes.io/docs/concepts/configuration/secret.
23. Kubernetes, “Use Port Forwarding to Access Applications in a Cluster”, consultato il 28/09/2026, kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster.
24. IETF, RFC 6902, “JavaScript Object Notation (JSON) Patch”, 2013, consultato il 28/09/2026, rfc-editor.org/rfc/rfc6902.