Matlab Read Doc

Use MathWorks Documentation

Systematic methodology for reading live MathWorks documentation. Provides a repeatable four-pass strategy (local catalog → help → user guide pages → reference pages) that turns documentation lookup into a predictable, efficient operation. Uses MATLAB's webread via MCP to fetch pages, with helper scripts that handle URL discovery, HTML parsing, and content extraction.

When to Use

• You are answering a "How do I..." question related to MathWorks products and workflows
• You guessed a URL and got 404 — use this skill to discover the correct URL from the index
• You need to find which functions exist for a product or workflow — start with the local function catalog
• You need to verify a function's syntax, arguments, or deprecation status from the authoritative source
• You want to check MathWorks best practices for a specific workflow
• Training-data knowledge is uncertain or potentially out of date for a release-specific API
• The user asks what MathWorks recommends for a specific topic
• You want a systematic approach that finds the RIGHT page (not just A page) in minimal tool calls

When NOT to Use

• The local help command is sufficient — prefer help function_name for API syntax; it's faster and always correct for the installed version
• The question is about general MATLAB programming patterns, not product-specific workflows
• You already have the authoritative answer from local help or a successfully fetched page

Fast Paths

Not every task needs the full four-pass strategy. Match the task to the shortest path:

| Task | Fast Path | Skip |

| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------- |

| Release notes / what's new | Fetch https://www.mathworks.com/help/{product}/release-notes.md directly via webread, then extract the ## R20XXx section | Steps 0-2 — no script needed |

| Known standalone function, need ref page | Use a URL from a prior extract_page_slugs call, or construct baseUrl + "ref/{name}.html" for simple standalone functions | Steps 0-2 — but URL must come from a verified source, not guessed |

| Know the product, need function list | get_local_function_list(product) | Steps 1-4 — no web needed |

| Unfamiliar API, no idea what exists | Full four-pass strategy | Nothing — use all steps |

Release notes

Release notes are available as clean markdown at https://www.mathworks.com/help/{product}/release-notes.md. Fetch this URL with webread, then extract the section between ## R20XXx and the next ## R header. No HTML parsing needed. Common product slugs: matlab, simulink, ecoder, rtw, stateflow, fixedpoint, hdlcoder.

Help Center Page Hierarchy

• Product landing page — Lists top-level categories with short descriptions. Use to discover section slugs.
• Intermediate category page — Links to subcategories with one-line descriptions. No leaf content. Drill deeper.
• Lowest-level category page — Contains reference groups (functions, blocks, apps) then links to related topics and examples.
• Topic pages (ug/ or product-specific path) — Conceptual or task-based content explaining how to use a feature.
• Example pages — Standalone worked examples with supporting files. May include live scripts, data files, or models.
• Reference pages (ref/ or slref/) — Function, block, object, or property reference. Multiple subtypes: function ref, object ref, property list, block ref, app ref.
• Getting started pages (gs/) — Introductory tutorials for new users of a product.
• Sequential topics (STEP 1, 2, 3) indicate a workflow with an intended order.

Choosing What to Fetch

MathWorks doc has two content layers that serve different purposes:

• Guide pages (user guide topics, typically under ug/) — Show *which* functions to call and in *what order*. Workflow-oriented. Best for learning a new API or deciding an approach. Note: not all products use ug/ — some (Simulink, Statistics and Machine Learning) use different subdirectory structures. Always discover via the section index.
• ref/ pages (function/object reference) — Show *exactly how* to call each function: full syntax, argument types, name-value pairs, valid enum values, return types, per-argument examples. Best when you know the function but need its exact signature. Some products use product-specific variants (e.g., Simulink uses slref/).

You typically need both. The ug/ page tells you the recipe; the ref/ page tells you the ingredient specifications. Skipping ref/ means guessing at property names and argument values — which frequently fails because MathWorks APIs use domain-specific names that aren't intuitive (e.g., "ArxmlFilePackaging" not "FilePackaging", "StopTime" not "SimulationDuration").

Page value signals (product-independent)

| Signal | Likely high value | Likely low value |

|---|---|---|

| Slug contains programmatically, program-, or command-line | Yes — always programmatic | — |

| Slug contains property-map-functions | Yes — API workflow | — |

| Slug contains explorer, interactively, using-...editor | — | Yes — GUI-only |

| Page type is ref/ with object or function name | Yes — exact signatures | — |

| Page is very large (>30K) with product that has GUI+programmatic paths | — | Suspect GUI — measure before reading |

| Page under ~1500 chars between Main Content and footer | — | Likely a navigation stub or redirect |

| Slug starts with example- | Mixed — check if it opens with GUI wizard or live-script code |

| ref/ page listing "-properties" in slug | Yes — property name/value lookup table |

Four-pass strategy

Entry rule: If you have a function name from the user's request or from a get_local_function_list call in this session, start at Step 2. Do not skip Step 1 based on training-data knowledge alone — function names change between releases and guessed names waste calls.

• Discover functions via the local catalog: Run get_local_function_list('product', 'keyword') to find which functions exist. Only use this when you don't have a function name yet.
• Get signatures with help: Run help functionName or help namespace. If help answers your question, stop here — don't fetch the web page.
• Third pass (ug/): If you need *workflow context* — which functions to call before/after, how they compose, or which of several approaches to take — fetch the ug/ page with programmatically in the slug. This gives you the call sequence and overall pattern.
• Fourth pass (ref/): If help was insufficient for a specific function (truncated output, missing name-value arguments from recent releases, need the full property enumeration, or need valid categories for a find call), fetch its ref/ page.

When help is enough (most of the time)

• Syntax and basic arguments for any function
• Block descriptions (help simulink/Gain)
• Class and object reference (help Simulink.SimulationInput)
• Listing all functions in a namespace (help matlab.io) or methods on an object (methods(obj))
• One-line descriptions of what each function does
• Input/output argument types
• Simple usage examples

When help is NOT enough (fetch the web page)

• Web ref/ page: name-value arguments added in recent releases; the full property name enumeration for a settings/properties object; valid enum values for an argument; which category strings are valid for a find call; help output is truncated or incomplete.
• Web ug/ page: workflow context (what to call before/after); understanding how multiple functions compose together; the task has GUI and programmatic paths and you need to find the programmatic one; decision guides for choosing between approaches.

URL Patterns

MathWorks documentation URLs follow these patterns. Do not guess — use the index to discover slugs.

Building documentation URLs

All documentation URLs are versioned under /help/releases/R20XXx/ and default to the installed MATLAB release. URL construction is handled internally by fetch_product_index — you do not need to build URLs manually. Get page URLs from one of these verified sources:

• hrefs output of fetch_product_index — full URLs returned directly, ready to use
• fullUrls output of extract_page_slugs — full URLs from a section index

baseUrl already includes the product path (e.g., https://www.mathworks.com/help/releases/R2026a/autosar/). Append only the sub-path: baseUrl + "ref/name.html" or baseUrl + "ug/topic.html". Never re-add the product name.

Page type patterns

| Page type | Pattern | Example |

| --------------- | ------------------------------------------- | ------------------------------------------------------------------------------ |

| Product index | {base}/{product}/index.html | https://www.mathworks.com/help/releases/R2025b/simulink/index.html |

| Section index | {base}/{product}/{section-slug}.html | https://www.mathworks.com/help/releases/R2025b/simulink/block-libraries.html |

| User guide page | {base}/{product}/ug/{page-slug}.html | https://www.mathworks.com/help/releases/R2025b/simulink/ug/some-topic.html |

| Reference page | {base}/{product}/ref/{function-name}.html | https://www.mathworks.com/help/releases/R2025b/matlab/ref/plot.html |

URL structure varies by product. Always crawl the section index to discover actual slugs — do not guess subdirectory names.

| Product | Guide pages | Reference pages |

| ---------------- | ------------------------------------------------------------------ | ------------------------------------------------------------ |

| matlab | matlab_prog/slug.html, matlab_oop/slug.html — multiple subdirs | ref/name.html |

| simulink | ug/slug.html | slref/name.html (also gui/ for configuration parameters) |

| systemcomposer | ug/slug.html | ref/name.html |

| autosar | ug/slug.html | ref/name.html |

| stateflow | ug/slug.html | ref/name.html |

For MATLAB, flat slugs with no subdirectory (e.g. debug-code.html) are usually section navigation pages. When crawling a section index, hrefs appear as relative paths — prepend the base URL to construct the full URL.

Common product slugs: matlab, simulink, systemcomposer, stateflow, autosar, ecoder, fixedpoint, stats, control, signal, dsp, deeplearning, images, optim, robust, mpc, sltest, parallel-computing

Scripts

MATLAB scripts automate the repetitive fetch-and-parse steps. These are function files — they require input arguments and must be called via evaluate_matlab_code, NOT run_matlab_file.

How to invoke

Use evaluate_matlab_code with project_path set to this skill's scripts/ directory (the "Base directory for this skill" shown at the top of this prompt, plus /scripts).

Do NOT use run_matlab_file — these are functions that require input arguments.

Tool: evaluate_matlab_code
code: "[t, hrefs] = fetch_product_index('simulink', 'Modeling')"
project_path: "<base-directory-for-this-skill>/scripts"

Script reference

| Script | Signature | Purpose |

| --------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |

| get_local_function_list.m | results = get_local_function_list(product, searchTerm) | Read complete categorized function list from local MATLAB install (fastest, works offline) |

| fetch_product_index.m | [t, hrefs, baseUrl] = fetch_product_index(product, search, rel) | Auto-detect release, fetch product index, return section links AND base URL for reuse |

| extract_page_slugs.m | [slugs, fullUrls] = extract_page_slugs(sectionUrl) | Extract page slugs and full URLs from a section index |

| fetch_doc_page.m | content = fetch_doc_page(url, maxChars, startChar) | Fetch a doc page and extract readable text (default 50K char limit). Pass startChar to paginate. |

| find_replacement.m | find_replacement(url) | Search a page for deprecation/replacement language |

| DocUtilities.m | Static class (not called directly) | Shared utilities: HTML stripping, link extraction, URL resolution. Used internally by other scripts |

Workflow

Use the Fast Paths table above to determine which steps to skip. The full workflow below is for unfamiliar APIs where you don't know what exists.

Step 1 — Try help first (when you have a function name)

If you have a function name from any source, start here:

help set_param               % function reference
help Simulink.SimulationInput  % class reference

If help answers your question, stop here. This is the most common entry point.

Step 1b — Discover functions via the catalog (when you don't have a name)

If you don't know what function to call, discover what exists:

results = get_local_function_list('ecoder');
results = get_local_function_list('simulink', 'code generation');

Returns a table with Name, Purpose, and Category. If you don't know the product slug, call get_local_function_list('unknown') to list available slugs. Then proceed to Step 1 with the discovered function names.

Step 2 — Navigate the product index to find the right page

fetch_product_index auto-detects the release, constructs the base URL, and returns section links:

[t, hrefs, baseUrl] = fetch_product_index('simulink', 'Modeling');

The third output baseUrl is the resolved version-aware URL — reuse it for all subsequent fetches in this session.

Step 3 — Fetch a section index to get page slugs

Use a URL from hrefs (returned by fetch_product_index) directly — do not construct URLs manually:

[slugs, fullUrls] = extract_page_slugs(hrefs{2,1});

Step 4 — Fetch and extract a specific page

content = fetch_doc_page(fullUrls{3});           % from discovered URLs

For very large pages, limit output:

content = fetch_doc_page(pageUrl, 10000);        % limit to 10K chars

Step 5 — Verify deprecation notices and replacements

When help shows "not recommended", find the recommended replacement on the web page:

find_replacement(baseUrl + "ref/hist.html");

Instructions

HTML processing

HTML stripping is handled internally by the fetch scripts (fetch_doc_page, fetch_product_index, find_replacement). Do not reimplement HTML parsing — call the appropriate fetch script instead.

URL discovery — never guess

• When a URL returns 404, go up one level (section index or product index) and read slugs from the page content.
• Standalone function ref page URLs (one dot or none: plot, set_param) can also be constructed directly: baseUrl + "ref/{name}.html" — since baseUrl already includes the product path.
• Functions or objects with a namespace (e.g., Simulink.SimulationInput, autosar.api.create): use extract_page_slugs on the relevant section index to discover the correct URL.
• All other URLs must be discovered from index pages. The fetch_product_index function returns full URLs in hrefs — use them directly.

Variable naming

Avoid names that shadow MATLAB built-ins: dir, input, length, size, path. If already shadowed in the workspace, use clear <name> before calling the built-in.

Product-specific URL patterns

• MATLAB: Has multiple subdirectories (matlab_prog/, matlab_oop/, ref/). Flat slugs with no subdirectory are almost always section navigation pages.
• Simulink: Uses ug/ for guide pages, slref/ for block/function reference, and gui/ for configuration parameters.
• System Composer, Stateflow: Use ug/ for guide pages, ref/ for reference. Straightforward hierarchy.
• Products with GUI+programmatic paths: Large character counts don't guarantee programmatic content — GUI-documentation pages can be 20K+ of UI element descriptions. Look for programmatically or program- in the slug as a reliable signal.

Release-specific documentation

• All URLs are versioned (/help/releases/R20XXx/). fetch_product_index defaults to the installed MATLAB release. Pass a release argument (e.g., "R2024b") to target a different version.
• Always verify help output first — it's guaranteed to match the installed version.
• If web docs describe features not available in help, the user may be on an older release. Note this discrepancy rather than assuming the API exists.

Copyright 2026 The MathWorks, Inc.