Neurarch MCP server

Read from the package source without running it. The installed server may list more.

• add_connection

  Wire two existing layers: a directed edge from "from" to "to". Fails on self-loops or duplicate edges. The target layer's cached shape is invalidated. Call save_model afterwards to persist.

• add_layerwrite action

  Insert a new layer into the model. Provide the layer type, a unique name, optionally an existing layer to auto-connect from, and any layer-specific params. Returns the new layer id. Call save_model afterwards to persist to disk. WARNING: this mutates the model. Call layer_impact first when inserting into the middle of an existing path so you can warn the user about cascading shape changes.

• check_design

  Get Neurarch's full verdict on this model: is it structurally sound and ready to train, what will a training run cost and how long will it take, which deployment target fits it best and at what latency, and which decisions are still the human's to make. Call this BEFORE proposing an architecture change and again after, so you can say what your edit actually did. Broader than validate_model, which

• check_edit

  Call after editing a model's config or architecture and before training. Give the pair: the base (base_model_path: a .py, a .neurarch.json, zoo:<id> or hf:<org/name>; or base_config) and the changed model (the server's model, model_path in the same forms, model_source, or config). base_config and config take a Hugging Face config.json as an object, as JSON text, or as a path. It returns the edits

• check_parallel_layout

  Call this BEFORE launching a multi-GPU training job split by tensor, pipeline, data, context or expert parallelism (Megatron, NeMo, DeepSpeed, torchtitan). It answers three questions from the model graph and the layout, before the job takes a reservation. Legal: does tp x pp x dp x cp multiply out, does TP divide the attention heads, the KV heads, the hidden and FFN widths, does EP divide the expe

• check_pins

  Find Hugging Face downloads that are not pinned to a commit, before a job or a deployment loads whatever `main` points at that day. Reads Python (from_pretrained, load_dataset, hf_hub_download, snapshot_download, pipeline), notebooks, shell scripts and Dockerfiles (vllm serve, the SGLang server, huggingface-cli / hf download) and YAML model keys. Three rules: pin/hf-unpinned (no revision, warn), p

• check_serving_config

  Call this BEFORE launching or changing a vLLM, SGLang or llama.cpp server for a model (a new checkpoint, a new card, a new --max-model-len or quantization). Pass the launch command as you would run it (command), or already-parsed engine arguments (args, camelCase: tp, maxModelLen, maxNumSeqs, gpuMemoryUtilization, quantization, kvCacheDtype, ...), plus the card (gpu: h100, a100-80g, l40s, l4, ...)

• compare_layers

  Structurally diff two layers: whether they are the same type, their parameter-count delta, whether input/output shapes match, and exactly which param keys differ (only-in-a, only-in-b, and changed values). Use to answer "are block_0 and block_1 identical?" before deciding whether an edit to one should mirror to the other, or whether two blocks can share an implementation. When either layer cannot

• delete_connectionwrite action

  Remove a single directed edge between two existing layers. The target layer's cached shape is invalidated. Fails when no such edge exists. Call save_model afterwards.

• delete_layerwrite action

  Remove a layer and every connection touching it. Cached shapes on former downstream layers are invalidated and the layer is removed from any groups it belonged to. Returns the list of layers whose shape contracts must be recomputed and the groups affected. Call save_model afterwards. WARNING: this is destructive. Call layer_impact first if the layer sits in the middle of an active path.

• describe_architecture

  One-call orientation: topologically-ordered layer pipeline, model depth (longest path), input/output shapes, total params and MACs, the top-5 heaviest layers by parameters AND by compute, and a validation rollup. Use this instead of chaining get_model_summary + param_count_by_block + flops_by_block + validate_model: it answers "what is this model and where is the budget" in a single call.

• diagnose_oom

  Call this after a CUDA out-of-memory error, before changing batch size. Pass the error text as printed (either PyTorch wording) and, when you can, the model and the job: model_path (a .py, a .neurarch.json from neurarch-trace, zoo:<id>, hf:<org/name>) or hf_id, plus batch, seq_len, the step it failed at, and attention. It reads the allocated, reserved-but-empty, other-process and failing-request n

• diff_models

  Structurally diff the current model against another .neurarch.json file: layers only in current, only in the other, and modified (with field-level changes), plus added/removed connections. Layers are matched by name. Use to review what changed between the model and a saved checkpoint or variant. "current" is the loaded model; the file you pass is "other", so onlyInCurrent is what this model adds r

• export_pytorch

  Render the current graph as a runnable PyTorch nn.Module, the same generator behind the app's Export panel. Use it after editing the graph with the write tools, or to hand a zoo:/hf: architecture to the user as code. The source is returned; pass save_to to also write it to a file (honoured only under --write, and never over the .py this server was started from: the graph was derived from that file

• find_layers

  Search layers by type, name regex, scope prefix, and/or applied augmentation, then optionally rank by parameter count. Answers "where are all the convolutions?", "which layers under encoder.layer.3 are frozen?", or "what are the 5 biggest layers?". Returns name, type, scope, param count, and any augmentations, and call get_layer for full detail.

• find_models

  Walk a directory for model definitions: .py files declaring an nn.Module subclass and saved .neurarch.json graphs. Each .py is tried against the parser, so the answer distinguishes files this server can read now from ones that need a runtime trace (neurarch-trace). Use it on arrival in an unfamiliar repository, then pass the path you want as model_path to any other tool. Skips node_modules, virtua

• find_path

  BFS shortest directed path from one layer to another. Answers "does encoder.0.attention reach lm_head?": returns the ordered list of layer names along the path, or null when unreachable. Useful before recommending an edit to confirm two layers are actually on the same flow.

• flops_by_block

  Group MAC counts (FLOPs \xF7 2) by block, scope, or type. Answers "where is compute spent?"; pairs with param_count_by_block to find parameter-light but compute-heavy regions (attention) versus the inverse (large MLPs).

• get_block

  Drill into one block (named group, or a scope prefix like "encoder.layer.0"): its member layers with per-layer params and FLOPs, the block totals, and the edges crossing the block boundary: what feeds the block and what it feeds. Use after list_blocks to understand how a block connects to the rest of the graph before recommending extracting, replacing, or freezing it. When the name resolves to no

• get_design_notes

  Return the model's pinned design rationale: notes the user promoted from advisor warnings or agent replies, or typed manually. Each note has source/title/body/createdAt and optional affected layer ids. Use this to ground recommendations in the user's stated intent for the architecture before suggesting a change.

• get_layer

  Return the full definition of a single layer (params, shapes, notes, connections). Looks up by exact name first, then by id, then by case-insensitive substring. When nothing matches, the error names the closest layer names.

• get_model_summary

  Return a one-shot overview of the Neurarch model: layer count, connection count, total parameters, dominant layer types, and the input/output shape. Use this first to orient yourself before drilling into specific layers.

• history

  What happened the last time this exact structure trained inside your organisation: the metric it reached, how many epochs, how long, what it cost. Keyed by the graph's 8-character structural fingerprint, so it answers about the shape rather than the file, and two people who arrived at the same architecture see the same runs. Pass model_path for a model, or fingerprint to ask about one directly (a

• layer_impact

  Compute the blast radius of changing a layer (or a regex-matched set): every upstream and downstream layer reachable through connections, flagged for shape sensitivity and weight rebuild requirements. Use this BEFORE recommending a destructive edit so you can warn the user about cascading effects. Mirrors the GitNexus impact tool.

• lint_modelwrite action

  Run Neurarch's structural design rules over the model, offline and with no API key: attention head-dim and GQA divisibility, normalization and activation ordering, dropout and feature ranges, missing residuals in deep stacks, and the shape rules that can be decided statically. Returns findings with a stable rule id and severity (block | warn | info). This is the same rule set the Neurarch CI actio

• list_architectures

  Search the reference library bundled with this server: verified graphs of published architectures (DeepSeek-V3, Qwen2.5, Llama, Mixtral, Whisper, CLIP, BERT, ViT, ResNet and more), each with real dimensions from the model's config and a parameter count checked against the published one. Offline. Any read tool can then be asked about an entry by passing model_path: "zoo:<id>", so you can compare th

• list_blocks

  List the model's collapsed groups ("blocks"): name, member count, params, FLOPs. Returns scope-derived blocks (dotted module path prefixes) when no explicit groups exist. Use this to talk about the architecture at a high level instead of layer-by-layer.

• list_connections

  Return every connection as {from, to, label?}, with optional filters by source or target layer name. Useful when get_layer's upstream/downstream is not enough and the agent needs a flat edge list (e.g. for "what are all the residual links?").

• list_hyperparams

  Dump the model-level hyperparameter table (learning rate, batch size, dropout, etc.) the user has set in the Neurarch hyperparams panel. Empty object when none defined. These are training-config knobs, NOT per-layer params.

• load_architecture

  Open one reference architecture from the bundled library and describe it: pipeline, depth, parameter and compute hotspots, validation. Pass save_to to write it out as a .neurarch.json the user can edit in the app or start this server on (requires --write). For further questions, pass model_path: "zoo:<id>" to any tool.

• load_hf_model

  Build a graph for a Hugging Face model from its config.json and describe it. This is the one tool that reaches the network (huggingface.co only; HF_TOKEN is sent for gated repos), which is why it is listed only when the server runs with --hf. The result says whether it came from the real config or a generic family template (configSource), and quotes the parameter count HF publishes so you can see

• mermaid_diagram

  Render the model as Mermaid flowchart syntax (top-down). The caller wraps the result in ```mermaid``` fences. Use sparingly: it gets noisy past ~30 layers; pair with namePattern via find_layers to give the user a clearer mental model.

• model_changes

  Reaches the network: GETs three public files from www.neurarch.com (no key, nothing about your code is sent). What changed in a tracked open-weight model on the Hugging Face Hub, revision by revision: config, tokenizer, chat template, generation defaults or weights, with the keys that changed, whether the change touches memory, serving or the tokenizer, and whether it is breaking under the publish

• modify_layer

  Modify an existing layer: shallow-merge new params, rename, or change scope. Returns a before/after diff. Cached shapes on this layer are invalidated when params change, so the user should reopen the model in Neurarch to recompute shape contracts. Call save_model afterwards. WARNING: shape-changing edits propagate downstream, so call layer_impact first.

• param_count_by_block

  Group parameter counts by block (named group), scope (dotted module path), or layer type. Answers "where do my parameters live?", useful for finding bloated subnets.

• plan

  The plan card for this design, rendered by Neurarch: will it run, what it will cost, which GPUs it fits, which of the repository's own rules it breaks, what changed against a base design, and what happened last time this structure trained here. This is the one tool that sends the graph off the machine (POST /api/v1/plan), which is what buys the last two lines; everything else in this server is loc

• rank_designswrite action

  Order several candidate designs for the one decision an agent cannot make by inspection: which of them to spend a training run on. Candidates are model files (model_path), zoo:<id> or hf:<id> references, or inline graphs; include_current adds the model this server holds. Blocked candidates (a pre-flight finding that means the graph will not forward-pass) rank last and are reported as budget you ca

• save_model

  Persist the current in-memory model to disk. Writes to the file passed on the command line by default; pass "path" to write elsewhere (will overwrite). Call this AFTER add_layer / modify_layer / add_connection: those tools only mutate memory. Returns the written path and byte count.

• size_training_job

  Call this BEFORE submitting or launching any training job (a sbatch, a Kubernetes Job, a cloud GPU reservation, a `python train.py` on a rented card). It answers what the job actually needs: the training peak memory at your batch, split into weights plus optimizer state, activations and stored attention scores; the smallest card that holds it; the largest batch each card (T4, L4, A10G, L40S, A100-

• suggest_fix

  Turn lint findings into edits to the source file: a unified diff per finding, labelled exact (a number or an order the rule pins, changed on every line that shares it) or proposal (a missing layer inserted with a note on what forward() still needs). Works on a .py; for a .neurarch.json use the write tools. Findings with no mechanical fix come back under notFixable with the reason. Apply the diff,

• trace_model

  Trace the model at runtime with neurarch-trace (pip install neurarch-trace) and get a graph with real shapes: instantiate it in Python, run one forward pass with hooks, write a .neurarch.json. Use when find_models or parseQuality says the static parse is thin or partial. target is "path/to/file.py:ClassOrFactory", "module.path:attr" or "hf:<repo>"; input is the batch-first dims per model input. Th

• validate_modelwrite action

  Run structural invariants over the model: cycles, dangling connection refs, duplicate ids/names, and orphan layers (no upstream / no downstream). Call before recommending a destructive edit so you can flag pre-existing issues separate from your change. Returns a list of findings with severity error|warn.

• Code scan4 source files scanned20/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitylocal package, no credentials required12/15
• Maintenancelast push 6 days ago15/15
• Maintainer identityregistry namespace matches repository owner6/10

Safety score

82/100

higher than 65% of 4,461 AI and agents servers

Tools

42

the typical AI and agents server has 6

Tools that change things

14%

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

GitHub stars

1

more than 50% of 2,713 AI and agents servers

Downloads a week

525

more than 87% of 1,554 AI and agents servers with a package

Neurarch: common questions

Is Neurarch MCP server safe?

Mostly: it is graded B (82/100). Read the Neurarch safety report

How do I install Neurarch?

It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.

Does Neurarch need an API key?

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

Is Neurarch maintained?

The last commit was 13 days ago (2026-10-23). The latest release is v0.21.0.

What can I use instead of Neurarch?

Servers from other publishers that do the same job: Doc Bridge MCP server, Basic Memory MCP server and Decionis MCP server.

How does Neurarch compare with other AI and agents MCP servers?

safety score 82/100 (higher than 65% of 4,461 AI and agents servers); tools 42 (the typical AI and agents server has 6); tools that change things 14% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.