Brainkb MCP server

• brainkb_activate_userFree

  (Admin) Activate a user's account (sets the JWT user active) by email.

• brainkb_add_access_ruleFree

  (Space manager) Restrict a space action to a subject. action: 'read' | 'write' | 'manage'. subject_type: 'global_role' (e.g. 'Admin','Lab Member') | 'member' (an email) | 'space_role' ('viewer'|'editor'|'owner', matched as >=). When rules exist for an action, only matching callers may perform it; the space owner and Admin/SuperAdmin always bypass (no lockout). Example: restrict writing to Admins -> action='write', subject_type='global_role', subject_value='Admin'.

• brainkb_add_space_graphFree

  Register a named graph and bind it to a space, so ingest/read on that graph are governed by the space's membership and visibility. Owner/editor only. The named_graph_iri is **globally unique** — one graph belongs to exactly one space. If it's already registered (to any space) the call returns 409; graph bindings are permanent (no unregister/delete).

• brainkb_add_space_memberFree

  Add/update a space member. role: 'owner' | 'editor' | 'viewer'. Owner only.

• brainkb_assign_roleFree

  (Admin) Assign a role/group to a user by email (e.g. 'Lab Member', 'External', or a custom group). The user must already have a profile (created on first login/registration). NOTE: assigning the 'Admin'/'SuperAdmin' role is SuperAdmin-only (hierarchy: SuperAdmin > Admin).

• brainkb_available_rolesFree

  (Admin) List the available roles/groups (Admin, Lab Member, Curator, …).

• brainkb_ban_userFree

  (Admin) Ban a user by email (reversible; preserves history). This is how accounts are removed — there is NO hard delete. Banning an Admin is SuperAdmin-only; SuperAdmin accounts cannot be banned.

• brainkb_capabilitiesFree

  (Admin only) Show a user's roles, effective capabilities, and delegated grants. Useful to check why someone can/can't create team spaces, ingest, etc.

• brainkb_create_permissionwrite actionFree

  (Admin) Create a new usermanagement permission, e.g. name='dataset.export', resource='dataset', action='export'. Attach it to roles via the usermanagement role-permissions API.

• brainkb_create_rolewrite actionFree

  (Admin) Create a new role/group — e.g. an 'External' collaborator group — which can then be assigned with brainkb_assign_role.

• brainkb_create_spacewrite actionFree

  Create a workspace/space. The caller becomes owner. slug: lowercase/hyphen id, **globally unique** — if it's already taken the call returns 409 (pick another slug; slugs are never reused/deleted). visibility: 'private' or 'public'; description: short human description (recommended — surfaces in the registry); space_type: 'individual' (a personal space — any write-capable role) or 'team' (a shared space — only Admin/SuperAdmin, or a user granted create_team_space).

• brainkb_create_tokenwrite actionFree

  Generate a Personal Access Token (PAT) for browser-free auth. Requires you to be logged in already (brainkb_login or brainkb_globus_login). The token is shown ONCE and never again — copy it and set it as BRAINKB_TOKEN in your MCP/skill config; then no login or browser is needed until it expires. `name`: a label so you can tell tokens apart (e.g. 'laptop'). `days`: lifetime (default 90, server-capped). Treat the returned token like a password.

• brainkb_deactivate_userFree

  (Admin) Deactivate a user's account by email.

• brainkb_deltaFree

  The exact triples a job added (its delta), as JSON-LD.

• brainkb_delta_compareFree

  Compare two jobs' deltas: A-only / B-only / shared triple counts + triples.

• brainkb_delta_historyFree

  A named graph's change history: one entry per ingest delta (job, triple count, timestamp), newest first.

• brainkb_discard_uploadwrite actionFree

  Delete one of your staged uploads without ingesting it.

• brainkb_finish_loginFree

  Complete an OAuth login started with brainkb_globus_login by exchanging the one-time code shown in the browser for a session token. The code is single-use and never echoed back.

• brainkb_globus_loginFree

  Start an OAuth login (Globus / ORCID / GitHub) for THIS session — use this instead of brainkb_login when the user signs in with Globus rather than a password. Returns a URL to open in a browser; after signing in, the page shows a short one-time code — pass it to brainkb_finish_login(code) to complete. (The browser step is unavoidable: only the user can consent at the provider.)

• brainkb_grant_capabilityFree

  (Admin only) Delegate a capability to a user — e.g. 'create_team_space' or 'manage_team_space' so a Curator/Lab Member can create/manage team spaces. Grantable: create_private_space, create_team_space, manage_team_space, ingest, recover, read_private (NOT the admin-only 'grant'/'sparql_admin').

• brainkb_grant_role_capabilityFree

  (Admin only) Grant a capability to a whole role/group so EVERY member gets it — e.g. give a custom group 'uk_collaborator' the 'ingest' or 'create_private_space' capability. Grantable: create_private_space, create_team_space, manage_team_space, ingest, recover, read_private (NOT the admin-only 'grant'/'sparql_admin'). Create the group first with brainkb_create_role, then assign it to users with brainkb_assign_role.

• brainkb_ingest_filesFree

  Ingest local RDF files (ttl/nt/nq/rdf/owl/jsonld/json) into a named graph. Returns a job_id; runs in the background — poll with brainkb_job_status.

• brainkb_ingest_textFree

  Ingest raw RDF text (Turtle / N-Triples / JSON-LD, auto-detected) into a named graph. Returns a job_id; ingestion runs in the background — poll with brainkb_job_status. The graph must be registered (see brainkb_add_space_graph) and the caller must have write access to its space. `sha256` / `expected_bytes` are an integrity contract, and you should use them whenever the RDF came from a file. Ingest is append-only — no delete for triples, no unregister for a graph — so RDF that arrives here mangled is permanent. Because `data` is a string, it passes through the caller's context, where dense Turtle is exactly what gets silently altered: ligatures, Greek letters, embedded newlines, escaped quotes. Declare the digest of the bytes you MEANT to send (`shasum -a 256 file.ttl`) and this refuses the write on any mismatch, turning an unrecoverable corruption into a clean rejection.

• brainkb_ingest_uploadwrite actionFree

  Ingest a file you staged with `POST /upload` into a named graph. This is the route for a large local file: your HTTP client streams the bytes straight to this server over HTTPS, then you name the resulting upload_id here. The server reads its own staged copy and posts it to the ingest API internally, so the RDF never passes through a model's context — nothing to transcribe, no context-window ceiling, and no reason to split the document (splitting breaks blank-node identity and silently detaches triples, permanently). Stage a file with any HTTP client — the point is that the LIBRARY reads the file, so the bytes never pass through a model: import requests, hashlib, pathlib f = pathlib.Path("review.ttl") r = requests.post( "https://mcp.brainkb.org/upload", params={"filename": f.name, "sha256": hashlib.sha256(f.read_bytes()).hexdigest()}, headers={"Authorization": f"Bearer {TOKEN}"}, data=f.open("rb"), # streamed — never loaded into memory ) print(r.json()) # -> {"upload_id": "up_...", "state": "staged"} It returns an upload_id and the sha256 the server computed — compare it with your own before ingesting. Returns a job_id; poll brainkb_job_status, then reconcile brainkb_delta(job_id) against the triple count you expected. The staged copy is deleted once the ingest API has accepted the bytes.

• brainkb_job_statusFree

  Detailed status of one ingest job: status, progress %, current file/stage, per-file failures, and (when complete) a summary.

• brainkb_list_access_rulesFree

  List a space's fine-grained access rules (member/manager of the space).

• brainkb_list_capabilitiesFree

  (Admin only) Catalog of all KG capabilities, which are delegatable ('grantable'), which are admin-only, and a description of each. Use this to see the available permission options before granting to a user or group/role.

• brainkb_list_jobsFree

  List the user's ingest jobs (newest first) with status and progress.

• brainkb_list_permissionsFree

  (Admin) List all usermanagement permissions (resource/action pairs used for page-access and role-permission mapping). These are the addable 'permission' options; KG action-capabilities are listed by brainkb_list_capabilities.

• brainkb_list_registered_graphsFree

  List registered named graphs visible to the caller (private-space graphs the caller can't access are hidden).

• brainkb_list_spacesFree

  List spaces the user can see (their own/member spaces + public ones), each annotated with THIS caller's permission so you know what they may do: - your_role: 'owner' | 'editor' | 'viewer' | null (their space membership) - is_owner: they own the space - access: 'owner' | 'member' | 'public' (how it's available to them) - can_write: their space role permits ingest (owner/editor) — a real ingest also needs the 'ingest' capability + any per-space access rules. Use this to tell the user which spaces they can read vs. write vs. only see as public.

• brainkb_list_tokensFree

  List your Personal Access Tokens (metadata only — the secret is never shown): id, name, prefix, created/last-used/expiry, and whether each is active/revoked/expired. Use the id with brainkb_revoke_token.

• brainkb_list_uploadsFree

  List RDF files YOU have staged with POST /upload but not yet ingested. Shows each upload_id, its size, sha256 and when it expires. Only your own uploads are visible.

• brainkb_list_usersFree

  (Admin) List users (profiles) — filter by `q` (name/email/orcid) or `role`. Shows profile_id, email, roles, providers, ban status.

• brainkb_loginFree

  Authenticate to BrainKB with the user's credentials and cache the JWT for THIS session only (isolated per caller). The password/token are never echoed. Uses single sign-on: one login mints a refresh token, cached for THIS session, which is exchanged on demand for per-service access tokens (query_service, usermanagement, …). Falls back to a legacy per-service token if the backend has no SSO. On the hosted multi-user remote you can skip this and instead have your client send an 'Authorization: Bearer <token>' header (a refresh token unlocks all services).

• brainkb_logoutFree

  Forget the cached token for this session.

• brainkb_provenance_graphFree

  PROV-O ingestion/activity history (JSON-LD) for a named graph.

• brainkb_provenance_jobFree

  PROV-O provenance bundle (JSON-LD) for one ingest job.

• brainkb_read_spaceFree

  Read all RDF (JSON-LD) in a space's graphs. Public spaces are readable by anyone; private spaces require membership.

• brainkb_recover_jobFree

  Attempt to recover a stuck/errored ingest job (marks it recoverable/errored).

• brainkb_remove_access_rulewrite actionFree

  (Space manager) Delete a fine-grained access rule by its id (see brainkb_list_access_rules).

• brainkb_remove_rolewrite actionFree

  (Admin) Remove a role/group from a user by email.

• brainkb_revoke_capabilityFree

  (Admin only) Revoke a previously granted capability from a user.

• brainkb_revoke_role_capabilityFree

  (Admin only) Revoke a capability from a role/group.

• brainkb_revoke_tokenFree

  Revoke one of your Personal Access Tokens by id (see brainkb_list_tokens). Takes effect immediately — the next call using that token fails.

• brainkb_role_capabilitiesFree

  (Admin only) List the capabilities granted to a role/group (e.g. 'uk_collaborator', 'Lab Member').

• brainkb_searchFree

  Full-text search over the knowledge graphs, access-filtered by space visibility. Pass `space` to scope to one workspace, omit for a full search. Anonymous/other users never see private-space data.

• brainkb_set_space_visibilityFree

  Set a space 'public' (anyone, even anonymous, can read) or 'private' (members only). Owner only.

• brainkb_sparqlwrite actionFree

  Run an arbitrary SPARQL query. Requires an Admin/SuperAdmin role (the sparql_admin capability) — for ordinary questions prefer brainkb_search, brainkb_read_space, or the provenance/delta tools, which need no admin role.

• brainkb_unban_userFree

  (Admin) Lift a ban on a user by email.

• brainkb_upload_statuswrite actionFree

  State of one of your staged/submitted uploads. `state` is `staged` (waiting for brainkb_ingest_upload), `submitting` (the server is streaming it to the ingest API), `submitted` (accepted — `job_id` is set, poll brainkb_job_status) or `failed` (the staged bytes were KEPT, so retry with brainkb_ingest_upload rather than re-uploading).

• brainkb_use_tokenFree

  Use a Personal Access Token (brainkb_pat_...) for THIS session — an alternative to setting BRAINKB_TOKEN in the config. Validates the token, then caches it so subsequent calls authenticate with it. The token is never echoed.

• brainkb_whoamiFree

  Report the current caller's auth state (email, authenticated, and when the cached session expires). When signed in it also returns base_url — the backend THIS SERVER talks to, which on a hosted deployment is an internal address and says nothing about the caller's own machine.

• –Code scanremote-only server, no package to scann/a
• Live reliabilityremote reachable in 724ms20/20
• Tool poisoning53 tool descriptions checked15/15
• Auth qualityopen endpoint exposes 10 write-action tools with no auth3/15
• Maintenancelast push 7 days ago15/15
• Maintainer identitynamespace and repository owner differ; GitHub account older than a year6/10

Safety score

79/100

higher than 58% of 48,255 servers

Tools

53

the typical server has 7

Tools that change things

19%

typical: 0%. Fewer write tools means less an agent can break

Uptime

100%

of our recent checks; the typical remote server answers 100%

Response time

277 ms

faster than 51% of 30,031 servers

GitHub stars

4

more than 82% of 28,688 servers

Brainkb: common questions

Is Brainkb MCP server safe?

Mostly: it is graded B (79/100). Read the Brainkb safety report

How do I install Brainkb?

It runs remotely at mcp.brainkb.org. Add it to Claude Code, Cursor, VS Code or Claude Desktop with the snippets above, or call it through the mcp.market gateway without installing anything.

Does Brainkb need an API key?

Not as far as the registry entry and our scan can tell: no credentials are declared or required.

Is Brainkb maintained?

The last commit was 47 days ago (2026-09-18). The latest release is v0.1.0.

Is Brainkb up?

100% of our last 28 checks got an answer. We check remote servers about four times a day.

What can I use instead of Brainkb?

Servers from other publishers that do the same job: Codebase Memory MCP server and Neo4j Memory MCP server.

How does Brainkb compare with other MCP servers?

safety score 79/100 (higher than 58% of 48,255 servers); tools 53 (the typical server has 7); tools that change things 19% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.