MCP server · Org-owned · Audited from source
Memlab MCP server
by meta/memlabMIT licenceAudited 13 Nov 2026 · source d8f1c4ee2a62
Is it safe? No — BLOCK, grade F (53/100). It exposes 174 tools: 149 read, 25 write and 0 destructive. The audit recorded 39 findings (0 critical, 4 high, 5 medium, 26 low). Maintainer's description: A framework for finding JavaScript memory leaks and analyzing heap snapshots
Cite
Cite this page
ModelsAtlas. “Memlab MCP server (meta/memlab)”. Retrieved 13 Nov 2026. https://modelsatlas.com/mcp/meta/memlab
Why this is BLOCK. The audit found 0 critical and 4 high findings; the most severe is Code injection at packages/mcp-server/scripts/sync-tool-catalog.mjs:43. Each finding is listed below with its file and line.
Why this page is still public. People search for this server by name. Hiding it would leave them with the README's word alone; here they see what the code does. We list it so you can decide, and we do not show connect commands for BLOCK servers.
2 MCP servers are called Memlab. You are viewing meta/memlab. Compare all 2 →
- meta/memlab Org-owned★ 5,091✕BLOCK
- facebook/memlab Org-owned★ 5,067✕BLOCK
Trust audit
Audit 0.4.1 · full source read 13 Nov 2026
39 findings, listed below with the file and line each was found on. Grade A needs a sandboxed behavioural run too; this audit read the source only.
What the source does
- FilesystemDeclared2 observations
- NetworkDeclared7 observations
- ShellDeclared6 observations
- DependenciesNot pinnedSome ranges float
- SecretsFoundSee the findings
Findings (39)
Sorted by severity · the 25 most severe of 39 are listed
HIGHCode injectioncode.eval_exec · packages/mcp-server/scripts/sync-tool-catalog.mjs:43
return new Function(`return [${body}];`)();- Why
- evaluates text as code
- Fix
- remove; use a parser or a dispatch table
HIGHCode injectioncode.eval_exec · packages/mcp-server/src/fix-status.ts:105
exec(
- Why
- evaluates text as code
- Fix
- remove; use a parser or a dispatch table
HIGHCode injectioncode.eval_exec · packages/mcp-server/src/tools/check-health.ts:605
(val.includes('function(') && val.includes('module'))- Why
- evaluates text as code
- Fix
- remove; use a parser or a dispatch table
HIGHCode injectioncode.eval_exec · packages/mcp-server/src/tools/eval.ts:5704
'- ⚠ `node.retainedSize` / `node.retained_size` THROW inside eval (they read back ~0 on some loads). Use `helpers.retainedSize(id)` / `helpers.retainedSizes([ids])` / `helpers.aggregateRetained([ids])
- Why
- evaluates text as code
- Fix
- remove; use a parser or a dispatch table
MEDIUMHard-coded secretsinv.env_committed · website/.env
.env
- Why
- a real .env in the package
- Fix
- ship .env.example with placeholders only
MEDIUMInventory / provenanceinv.symlink · docs
docs
- Why
- link not followed
- Fix
- —
MEDIUMNetwork egressnet.raw_ip · packages/mcp-server/src/cdp-capture.ts:208
const endpoint = `http://127.0.0.1:${port}/json`;- Why
- No further detail recorded for this rule.
- Fix
- —
MEDIUMNetwork egressnet.raw_ip · packages/mcp-server/src/cdp-capture.ts:237
const endpoint = `http://127.0.0.1:${port}/json`;- Why
- No further detail recorded for this rule.
- Fix
- —
MEDIUMHard-coded secretssecret.generic · website/docusaurus.config.js:235
Excerpt withheld: it is a secret, and we never print one.
- Why
- No further detail recorded for this rule.
- Fix
- —
LOWCode injectioncode.eval_exec · packages/e2e/src/E2EInteractionManager.ts:159
eval(script);
- Why
- evaluates text as code
- Fix
- remove; use a parser or a dispatch table
LOWInsecure cryptocrypto.weak_hash · packages/mcp-server/src/guardrail.ts:369
const key = `para:${crypto.createHash('sha1').update(t).digest('hex')}`;- Why
- No further detail recorded for this rule.
- Fix
- —
LOWInsecure cryptocrypto.weak_hash · packages/mcp-server/src/tools/finding-index.ts:490
return crypto.createHash('sha1').update(material).digest('hex').slice(0, 12);- Why
- No further detail recorded for this rule.
- Fix
- —
LOWInsecure cryptocrypto.weak_hash · packages/mcp-server/src/tools/finding-index.ts:1147
.createHash('sha1')- Why
- No further detail recorded for this rule.
- Fix
- —
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EBasicAnalysis.test.ts:13
import {run} from '../../index';- Why
- No further detail recorded for this rule.
- Fix
- —
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EDetachedDOMAnalysis.test.ts:14
import {DetachedDOMElementAnalysis, warmupAndTakeSnapshots} from '../../index';- Why
- No further detail recorded for this rule.
- Fix
- —
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EDuplicateObjectAnalysis.test.ts:10
import type {BrowserInteractionResultReader} from '../../index';- Why
- No further detail recorded for this rule.
- Fix
- —
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EDuplicateObjectAnalysis.test.ts:14
import {ObjectShallowAnalysis, warmupAndTakeSnapshots} from '../../index';- Why
- No further detail recorded for this rule.
- Fix
- —
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EFindLeaks.example.ts:15
import {run} from '../../index';- Why
- No further detail recorded for this rule.
- Fix
- —
LOWObfuscation / stealthobf.decode_call · packages/e2e/src/NetworkManager.ts:121
? atob(response.body)
- Why
- No further detail recorded for this rule.
- Fix
- —
LOWSupply chainsupply.unpinned · package.json
ansi, babar, blessed, chalk, fs-extra, minimist, string-width, util.promisify
- Why
- 23 dependency range(s) float
- Fix
- pin exact versions or ship a lockfile
Tools it exposes
174 declared in source · 0 destructive
| Tool | What it does | Risk |
|---|---|---|
memlab_analysis_battery | Run a round | write |
memlab_analyze_run | Point at a leak hunt | write |
memlab_array_group_by | Iterate through array (or Map/Set) elements, extract a named property from each, and | write |
memlab_batch | Run several memlab tools against ONE snapshot load, in order, and return all their outputs together. | write |
memlab_cache_inventory | Inventory of MODULE-LEVEL collections (Map / Set / WeakMap / Array) — held directly by a module | write |
memlab_cache_sole_retainer | Module-level caches (Map / Set / Array held by a module scope or by an exported function, such as a memoizer | write |
memlab_check_health | Run all heuristic health checks in one call and return a prioritized list of findings. This is the recommended first step after loading a snapshot — it replaces calling 4-5 individual tools to triage. | write |
memlab_eval | Execute arbitrary JavaScript code against the loaded heap snapshot. | write |
memlab_eval_across | Run ONE | write |
memlab_find_by_shape | Find all objects that have a specific set of property names (multi-property intersection search). Unlike find_by_property which searches for a single property, this finds objects matching a | write |
memlab_ladder_probe | Run ONE numeric probe across an ORDERED ladder of snapshots and report the series, the per-cycle rate and a linear fit. | write |
memlab_map_entries | Enumerate the entries of ONE Map or Set (node_id is REQUIRED — this is not a global scan). The companion to memlab_weakmap_entries for strongly-held collections. The KEYS are usually the whole diagnosis of an unbounded cache: a Store/singleton Map keyed by | write |
memlab_probes | Save named probes for an app once, and have the ladder tools run them by themselves. A probe is | write |
memlab_prune_run | Reclaim the disk a round | write |
memlab_rate_model | Is this population UNBOUNDED, or is it a working set whose size is just a function of how fast the harness drove?\n\n | write |
memlab_react_update_queues | The React eager-bailout leak family as one report. A | write |
memlab_reports | Run curated memory analysis reports — like Chrome DevTools Memory panel views. Use | write |
memlab_shape_census_diff | Per-SHAPE growth across a LADDER: group objects by their property set at every rung and report the series, the per-cycle rate and the fit — the shape-level equivalent of | write |
memlab_stale_collections | Find Map, Set, and Array collections holding stale references. Detects: (1) detached DOM / | write |
memlab_start_job | Start ANY memlab tool as a background job and return a job id at once; collect the result with | write |
memlab_switch_matrix | Prove the judges can go red: run every invariant judge (as | write |
memlab_timers | Pending timers and scheduled tasks, grouped by the function they will run and what that function CAPTURES. Finds React Scheduler task records by shape ( | write |
memlab_validate_finding | Check a finding write-up against the evidence its claim needs, BEFORE it is filed. The finding is JSON: | write |
memlab_what_if | If this set of objects were freed, how many bytes would actually come back? Reports the dominator-deduped retained size of a population — the bytes that go away when it does, with nothing double-counted and nothing counted that is also reachable another way.\n\n | write |
stale_collections | Find Map/Set/Array collections holding references to detached or unmounted nodes | write |
class_histogram | Show instance count and total self size per class/constructor name | read |
detached_dom | Find detached DOM elements still retained in memory — common source of leaks | read |
duplicated_strings | Find duplicated string instances ranked by total size — common source of waste | read |
global_variables | Find non-built-in global variables on Window, sorted by retained size | read |
largest_objects | Find the top objects by retained size in the heap | read |
memlab_ab_compare | Judge an A/B round ( | read |
memlab_aggregate | Aggregate heap nodes by type, name, or name prefix. Returns grouped statistics (count, total self size, aggregate retained size) sorted by retained size. Retained size uses dominator-aware aggregation (no double-counting). | read |
memlab_allocation_sites | WHO ALLOCATED these objects: group live objects by the JavaScript stack that allocated them, from a capture recorded with allocation tracking (a .heaptimeline, or a snapshot taken while tracking was on). | read |
memlab_anonymize_snapshot | No description in the source | read |
memlab_app_config | Read the feature flags and config values the app was actually running with, out of the snapshot itself.\n\n | read |
memlab_app_heap | Report APP-ATTRIBUTABLE heap: total self size minus bundle/code memory, minus dev-build artifacts, minus measurement-harness content — the part of the heap that is actually the application. | read |
memlab_artifact_budget | ONE number for | read |
memlab_async_census | Census PENDING ASYNC WORK: React-scheduler task queues (with a live-vs-cancelled split), timer callback closures, and unsettled Promises with their owner shapes. | read |
memlab_auto_investigate | No description in the source | read |
memlab_battery_status | Report on a battery started with | read |
memlab_blink_native_census | Native (Blink) classes that grow across a ladder — | read |
memlab_bound_functions | Bound functions ( | read |
memlab_build_pair_compare | Line up a DEV-build round and a PRODUCTION-build round of the same interaction and say, per population, whether its growth is dev-only, production-real or production-only. | read |
memlab_build_provenance | Assert that the build a snapshot came from actually contains the change you are measuring, BEFORE reading any before/after number. Scans the heap for marker strings from the new revision ( | read |
memlab_cache_analysis | No description in the source | read |
memlab_calibrate_judges | No description in the source | read |
memlab_capture | Take fresh heap snapshots of a LIVE page and/or its dedicated WORKERS over the Chrome DevTools Protocol, without a harness script. | read |
memlab_census | Count several named POPULATIONS across every rung of a ladder in ONE pass per snapshot, and report each one | read |
memlab_census_diff | Take the detached-DOM and listener-record census at TWO rungs and diff them per class / per callback in one call. | read |
memlab_chain_walk | Walk a repeated linked structure from a starting node and report how deep it goes and what it holds — for closure chains ( | read |
memlab_class_histogram | Show per-constructor/class instance count and total self size. Useful for identifying which types of objects dominate memory. | read |
memlab_closure_inspection | Inspect a closure (function) OR a suspended generator/async frame to show its captured/live variables. | read |
memlab_co_holders | Find collections that hold the SAME objects or are keyed by the same keys: Maps, Sets and WeakMaps (Arrays with | read |
memlab_collection_diff | Find WHICH collections grew across a snapshot ladder, WITHOUT being told their names. Censuses every Map/Set/WeakMap/WeakSet/Array on every rung, keys each by a per-capture-STABLE | read |
memlab_collection_trend | Track named collections ACROSS a snapshot ladder: entry counts per rung, with per-cycle growth. memlab_cache_analysis, memlab_stale_collections and memlab_growth_signals all answer | read |
memlab_compare_rounds | Compare N rounds of a sweep and surface the patterns no single round shows.\n\n | read |
memlab_console_retention | Report what an attached DevTools console is keeping alive, and answer whether a specific object depends on it. DevTools holds a global handle on every object passed to | read |
memlab_count_population | Count one population by SEVERAL independent methods and report when they disagree.\n\n | read |
memlab_dead_context_variables | Find captured variables that no live code can read, heap-wide. Closures created in one scope share one Context, so a variable read only by a callback that is gone stays alive as long as ANY sibling closure does. | read |
memlab_detached_dom | No description in the source | read |
memlab_dev_artifacts | No description in the source | read |
memlab_dev_subtracted_delta | Per-class growth from | read |
memlab_diff_snapshots | Compare two heap snapshots: classes that grew, shrunk, appeared or disappeared between | read |
memlab_dom_audit | Budget the ATTACHED DOM and rank the surfaces worth virtualizing. This is an OPTIMIZATION tool, not a leak tool — the elements it reports are all live and correctly retained; the point is that there are too many of them.\n\n | read |
memlab_dominator_attribution | Given several candidate retainers, measure how much of a population each one actually DOMINATES — i.e. what would really be freed by releasing it. Answers | read |
memlab_dominator_chain | No description in the source | read |
memlab_dominator_subtree | Show the direct children in the dominator tree for a given node — i.e., objects whose retained size is exclusively attributed to this node. These are the objects that would be freed if this node were garbage collected. Useful for understanding what composes a large retained size. | read |
memlab_drill_to_heavy_leaf | Follow the retained size DOWN from one node to the object actually holding it, in a single call.\n\n | read |
memlab_duplicate_objects | No description in the source | read |
memlab_duplicated_strings | Find duplicated string instances in the heap. Shows strings that appear multiple times, ranked by total retained size — a common source of memory waste. Use after memlab_class_histogram shows high string counts. | read |
memlab_element_census | Retained React elements and fibers by component type. Fibers are split into mounted (reached by the committed tree from a root), alternate (a mounted fiber | read |
memlab_error_callsites | Where retained Error objects were created, read from the stack frames V8 captured on each Error (a private symbol holding each frame | read |
memlab_event_listener_leaks | Detect EventEmitter-style listener accumulation — the #1 cause of memory leaks in | read |
memlab_event_registry | Detector for per-model event registries (Backbone/Marionette/observer style): objects mapping event names to arrays of {callback, context} listeners, e.g. | read |
memlab_explain_delta | Explain WHERE a heap grew between two loaded snapshots, attributed by dominator (who owns the new bytes) rather than by class (what the new bytes are). | read |
memlab_external_strings | Attribute | read |
memlab_field_release_impact | If a fix nulls this property, how many bytes actually come back — and is the property the ONLY reference?\n\n | read |
memlab_find_by_property | Find all objects that have a specific property name (outgoing edge). Useful for identifying | read |
memlab_find_nodes_by_class | No description in the source | read |
memlab_finding_index | Fingerprint a leak finding by its retainer path and check it against findings from previous rounds, so a hunt does not spend itself re-discovering a known or already-fixed leak. | read |
memlab_fix_knowledge_check | Before writing a leak fix, answer true/false questions on the beliefs that most often send a fix the wrong way: a WeakMap hop read as the cause, a field nulled on a copy React keeps, a cache filling up read as a leak, a dev-only chain, a cleanup removed with a different function. | read |
memlab_for_each | Structured map/filter/reduce over all heap nodes. | read |
memlab_framework_buffers | Size the framework buffers that recur in every hunt on the same stack, in ONE call, minification-safe. Generic probes: in-memory | read |
memlab_gate_fingerprint | Decide which EXPERIMENT ARM the loaded capture is in by comparing it against a capture of the other arm, for gates | read |
memlab_get_node | Look up a heap node by its numeric ID. Returns full details including size, type, detachedness (attached / detached / unknown), distance from the root in hops, dominator, location, and string value if applicable. | read |
memlab_get_property | Look up a specific property (outgoing edge) of a heap node by name and return the target node with full details. Useful for traversing the object graph step by step (e.g., get the __proto__, stateNode, or memoizedState of a node). | read |
memlab_get_references | Get outgoing edges (references) from a heap node, sorted by target retained size (or | read |
memlab_get_referrers | Get incoming edges (referrers) to a heap node, sorted by source retained size (or | read |
memlab_get_string | Resolve any V8 string node to its full text value. Handles all V8 string encodings: | read |
memlab_get_value | Decode the actual numeric value of a V8 SMI (Small Integer) or heap number node. | read |
memlab_global_variables | Find non-built-in global variables on the Window object (browser) or global object (Node.js), sorted by retained size. These are application-specific globals that may indicate memory issues. | read |
memlab_growth_cohort | Group the NEWEST instances of a population by who holds them — top referrer edges, top shapes, top root-path heads, and their dominator-deduped retained size.\n\n | read |
memlab_growth_signals | No description in the source | read |
memlab_hunt_report | Render a leak hunt | read |
memlab_hypothesis | Test one hypothesis against EVERY rung of a snapshot ladder in a single call: supply a JavaScript predicate over heap nodes and get its match count, total self size, and trend per rung. | read |
memlab_id_space_audit | No description in the source | read |
memlab_identify | Name a minified structure from its property shape. In a production bundle nearly every class is | read |
memlab_identity_diff | Same objects, or just the same number of objects? Matches a population across two snapshots by CONTENT rather than by node id. Use it across isolates (a reload, another session); between captures of ONE isolate, memlab_diff_snapshots matches by V8 object id, which is exact.\n\n | read |
memlab_intern_opportunities | No description in the source | read |
memlab_island_doors | List EVERY production-reachable reference into an island, not just the shortest one. | read |
memlab_job_status | Report on a job started with | read |
memlab_judges | Judge a leak-hunt round against its stated INVARIANTS — plain-words claims about what must hold once the app is at rest — instead of reading | read |
memlab_ladder | Name a snapshot ladder once and reference it as | read |
memlab_largest_objects | Find the top N objects by retained size in the loaded heap snapshot. Filters out internal/meta objects. Use node_type to filter to a specific type (e.g., | read |
memlab_leak_report | No description in the source | read |
memlab_live_eval | Evaluate one JavaScript expression in a LIVE page over the Chrome DevTools Protocol and return its JSON value, to check a snapshot hypothesis against the running app (is a global defined, how long is a queue now, which keys does a debug object have) without a harness script. | read |
memlab_load_snapshot | No description in the source | read |
memlab_match_object | Find the object in ANOTHER loaded snapshot that corresponds to a given object in the current one. | read |
memlab_memory_partition | Answer | read |
memlab_metric | Record a measurement under a name and keep it across sessions, so a number measured today can be compared with one measured next week.\n\n | read |
memlab_model_census | Per MODEL TYPE in Backbone-style collections (objects carrying | read |
memlab_model_duplicates | Model instances that share an identity value (e.g. a message id at | read |
memlab_module_attribution | Attribute heap bytes to the MODULE that owns them, by walking the dominator tree up to the nearest module-registry export or module SCOPE (the top-level closure context a Haste | read |
memlab_module_present | Pre-flight: does a class/constructor appear in this heap AT ALL? Answers | read |
memlab_module_source | The SERVED source of one module, read from the snapshot: its | read |
memlab_native_contexts | Split ONE snapshot by JavaScript realm: the page, each iframe, extension isolated worlds, detached windows, Node | read |
memlab_next_measurement | What can the snapshots currently loaded actually support — and which capture would change that?\n\n | read |
memlab_object_cost_breakdown | No description in the source | read |
memlab_object_shape | Show the shape/structure of one or more heap objects: all named properties with target node types and sizes. Filters out internal/hidden edges to show only user-visible properties. Supports batch inspection via node_ids to compare multiple objects side-by-side in a single call. | read |
memlab_object_urls | Unrevoked | read |
memlab_overlap_matrix | Do these classes retain the SAME bytes? Reports pairwise overlap in dominator-deduped retained size, plus the | read |
memlab_path_tree | Show WHERE the memory sits as a tree: the shortest-retainer-path tree (each object hangs under the object on its shortest path from a GC root) with the app bytes of every subtree, expanded wherever a branch holds at least | read |
memlab_pending_promises | Unsettled Promises ranked by REACTION-CHAIN length, with retained size, the native (Blink task-attribution / soft-navigation) memory their reactions keep alive, and the production owner path. One promise that never settles keeps every | read |
memlab_persistent_structures | Detect persistent / structurally-shared data structures (Immutable.js Maps, Lists and trie nodes; Immer drafts; RxJS-style Subscriptions) and report how many VERSIONS are retained, with dominator-deduped bytes. Use it whenever a leak report shows growth in short minified classes ( | read |
memlab_pinch_points | Find | read |
memlab_population_diff | Compare the COMPOSITION of a population between two loaded snapshots, not just its size. Equal totals are not identity: a round that strands N objects and frees N others reports the same count at both ends, and reading that as | read |
memlab_population_vs_owners | Decide whether a population is STRUCTURAL (about one record per live owner) or ACCUMULATING (owners are collecting records), by counting both and reporting the ratio. | read |
memlab_positive_controls | Measure the round\ | read |
memlab_property_distribution | No description in the source | read |
memlab_property_names | Index the heap | read |
memlab_query_objects | Query heap objects by any combination of filters in ONE call, instead of chaining class search, node search and property inspection: class or node name (regex), node type, an outgoing property or edge name (regex), detached or not, the owning realm ( | read |
memlab_quick_diagnosis | No description in the source | read |
memlab_rate_table | Build the per-surface, per-cycle rate table for ONE metric across several rounds — the artifact that says which surface to fix first.\n\n | read |
memlab_react_owners | Name the React COMPONENT behind a population of plain | read |
memlab_realm_duplication | Find what is loaded TWICE across realms: given a page snapshot and its worker snapshots (memlab_capture writes them), list every module present in more than one realm with its state bytes in each realm, and the bytes that would go away if only the largest copy remained. | read |
memlab_realm_summary | Compare the heaps of several REALMS captured at the same moment — a page plus its dedicated workers (memlab_capture writes them) — as one table: per realm, app memory, bundle text, loaded code and dev-only bytes, plus the WebAssembly modules and SharedArrayBuffers it holds. | read |
memlab_referrer_summary | Group all incoming references (referrers) of a node by edge name and source class. | read |
memlab_replicate | Ask whether a measured effect REPRODUCES across two or more independently-driven runs, and refuse to call it real until it does. | read |
memlab_retained_by | How much of the heap is retained ONLY through each kind of retainer: closure contexts, detached DOM nodes, the DevTools console, and event handler functions. | read |
memlab_retainer_diff | A population grew between two snapshots — did it grow along the SAME retention path, or did a new one appear?\n\n | read |
memlab_retainer_layers | Counterfactual retainer analysis: answer | read |
memlab_retainer_summary | No description in the source | read |
memlab_retainer_trace | No description in the source | read |
memlab_retention_windows | List the retention windows this app has — timeouts, TTLs, cleanup intervals, eviction ages — before calling any growth unbounded.\n\n | read |
memlab_round_audit | Read a leak hunt | read |
memlab_round_digest | The verdict table for a finished leak-hunt round, and nothing else. | read |
memlab_scope_chains | Chains of contexts that share one ScopeInfo — each call of a function pinning the previous call | read |
memlab_script_census | Census the retained JS SOURCE TEXT in the heap, and flag the same bundle being retained more than once. | read |
memlab_search_nodes | General-purpose search for heap nodes by combining filters: name pattern (regex), node type, minimum retained/self size, and detachment status. Results sorted by retained size. Supports count-only and ids-only modes for large result sets. | read |
memlab_search_strings | Search the content (stringValue) of all string nodes in the heap snapshot. | read |
memlab_sequence_analysis | Trend analysis across an ORDERED sequence of >=2 heap snapshots (the canonical | read |
memlab_server_status | Cheap liveness/health check: returns instantly with the server VERSION, process RSS, uptime, and the resident snapshots. The version answers | read |
memlab_settle_check | Separate RETENTION from in-flight BACKLOG by comparing a busy snapshot against one captured after the app settled (idle + forced GC). | read |
memlab_shape_histogram | Group objects by their property structure (shape/hidden class). Objects with the same set of property names are grouped together, revealing distinct record types. Much more useful than class_histogram when most objects are generic | read |
memlab_sliced_strings | No description in the source | read |
memlab_snapshot_budget_planner | Which rungs of this ladder can you actually hold in memory at once, and which should be probed transiently?\n\n | read |
memlab_snapshot_header | Peek a .heapsnapshot | read |
memlab_snapshot_summary | Get an overview of the loaded heap snapshot: total nodes, edges, size, and per-node-type breakdown with count and self size. | read |
memlab_snapshots | No description in the source | read |
memlab_source_for_finding | A finding | read |
memlab_source_for_node | Which MODULE\ | read |
memlab_sparse_elements | Find integer-keyed objects and arrays whose ELEMENTS BACKING STORE is mostly holes — memory V8 has allocated and the application never uses. This is the waste a class histogram cannot see: the store is a | read |
memlab_stale_refs | React refs ( | read |
memlab_string_patterns | Group strings by common prefix and show aggregate counts and sizes. Instead of seeing 20 individual histogram entries for CSV strings that all start with the same header, see them grouped: | read |
memlab_string_prefix_census | Count strings by PREFIX on every rung of a ladder — | read |
memlab_sweep_digest | No description in the source | read |
memlab_synthetic_controls | Read a sizing round | read |
memlab_tools | Index of every memlab tool, grouped by the QUESTION it answers ( | read |
memlab_trace_all | Retainer-trace an ENTIRE population and cluster the paths server-side, instead of sampling a handful and hoping they are representative.\n\n | read |
memlab_trace_dominators | No description in the source | read |
memlab_unit_cost | How much memory does ONE of these actually cost? Reports dominator-deduped retained bytes per instance for a class or an object shape, | read |
memlab_verify_fix | Decide whether a fix actually worked, by comparing the per-cycle growth RATE of one metric between a before ladder and an after ladder. hunt_runner --ab drives both arms but nothing analyses them, which is why fix write-ups stall at | read |
memlab_weakmap_entries | No description in the source | read |
memlab_weakref_census | Census every WeakRef in the heap, split LIVE vs EMPTY (referent already collected), and group by the shape of the object holding them. | read |
Safer alternatives
All memory & knowledge servers →1ch1n/mychatarchive
Local-first AI memory archive. Import ChatGPT, Claude, and Grok exports, generate semantic embeddings, and search via MCP server. Zero cloud, zero cost.
yuchen20/memory-plus
🧠 Memory-Plus is a lightweight, local RAG memory store for MCP agents. Easily record, retrieve, update, delete, and visualize persistent "memories" across sessions—perfect for developers working with multiple AI coders (like Windsurf, Cursor, or Copilot) or anyone who wants their AI to actually reme
nirholas/alibaba-cloud-mcp
MCP server for Alibaba Cloud DashScope by three.ws — Qwen chat, embeddings, and model discovery using your own Alibaba Cloud API key.
Audit history
- ✕BLOCK F 53 / 100
First audit ·
d8f1c4ee2a62
README badge
Badges show the current verdict, BLOCK included
A badge cannot be hidden by the maintainer while the verdict is BLOCK. Fix the findings, push, and the re-audit updates it.
Questions about Memlab MCP server
What is the Memlab MCP server?
What tools does Memlab expose?
Is Memlab safe to connect to an agent?
What credentials does Memlab need?
How does Memlab run?
How current is this page?
Which Memlab MCP server is the right one?
I already installed Memlab. What should I do?
Can the verdict change?
Sources
- meta/memlab on GitHub — the source we read, its licence, stars and activityObserved · 13 Nov 2026
- ModelsAtlas trust audit — BLOCK verdict for commit d8f1c4ee2a62Observed · 13 Nov 2026
Spotted something wrong? Report a correction · Methodology
Keep going in your AI
Opens with this page as the source. We add nothing else to the prompt.
- What is the Memlab MCP server?
- What tools does Memlab expose?
- Is Memlab safe to connect to an agent?