matlab-read-documentation

name	matlab-read-documentation
keywords	docs documentation mathworks webread fetch lookup api reference function
description	Guides the agent to reference official MathWorks Documentation and Help. Determine correct function syntax and workflows from user guides when deeper context is needed. Minimize iterations and repetitive trial and error. Use this skill to: Identify correct syntax and configuration details. Retrieve relevant, version-specific (or release-specific) information from official documentation. Consult user guides when conceptual or workflow context is needed. Apply best practices.
license	https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md
metadata	{"author":"MathWorks","version":"2.0"}

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.

1. 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.
2. Get signatures with help: Run help functionName or help namespace. If help answers your question, stop here — don't fetch the web page.
3. 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.
4. 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:

1. hrefs output of fetch_product_index — full URLs returned directly, ready to use
2. 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.