Get connection status and system info.

Compact session state summary: connection, profile, recent errors, routing advice.

List all open Mathematica notebooks. Returns ID, filename, title.

Get details about a notebook (filename, directory, cell count).

[ADVANCED] Create a new empty notebook.

Use when the user explicitly asks for a NEW notebook. This sets the active notebook so subsequent execute_code(style="notebook") calls write into it. Without this, execute_code reuses the currently open notebook.

For code execution in whatever notebook is already open, use execute_code(style="notebook") directly instead.

Save a notebook to disk.

Close a notebook.

Get list of cells in a notebook.

Get the full content of a specific cell.

[ADVANCED] Write a cell without evaluating it.

Prefer execute_code(style="notebook") for code execution. Use write_cell only for deliberate manual notebook authoring, such as text, section headers, or carefully controlled cell-by-cell construction.

Delete a cell from a notebook.

[ADVANCED] Re-evaluate an existing cell in a notebook.

Prefer execute_code(style="notebook") for fresh execution. Use evaluate_cell only when you already have a notebook cell and need to re-run that specific cell.

[PRIMARY] Execute Wolfram Language code. Prefer this for nearly all computation and plotting.

Choose a style:

• style="compute" — fast kernel evaluation, result in chat

• style="notebook" — evaluate in kernel, show in notebook cell

• style="interactive" — front-end evaluation (required for Manipulate/Dynamic)

style is a high-level preset for output_target + mode. Individual params still work and override style. When style and output_target are both omitted, output_target defaults to the profile's default (notebook) and mode defaults to kernel.

response_detail accepts the canonical levels compact, standard, verbose, and diagnostic, plus the aliases short, medium, and long.

Prefer this over write_cell + evaluate_cell for running code. With output_target="notebook", it reuses the active notebook (or creates one if none exists), writes the code, and evaluates it in one call. If notebook transport fails, the request returns a notebook-targeted error instead of silently rerunning through CLI fallback. NOTE: if the user asks for a NEW notebook, call create_notebook first.

Execute multiple commands in one round-trip.

[ADVANCED] Evaluate the currently selected notebook cell or cells.

Prefer execute_code(style="notebook") for fresh execution. Use evaluate_selection only for explicit notebook-selection workflows.

Capture a screenshot of an entire notebook window.

Args: notebook: Notebook ID. If None, uses selected notebook. max_height: Maximum height in pixels (prevents huge images)

Returns the screenshot as an image that can be viewed directly.

Capture a screenshot of a specific cell's content and output.

Useful for seeing plots, graphics, or formatted mathematical output.

Args: cell_id: The cell object ID to screenshot

Render a Wolfram Language expression as an image.

Useful for visualizing plots, matrices, or formatted output without modifying any notebook.

Args: expression: Wolfram Language expression to render image_size: Size of the resulting image in pixels

Examples: rasterize_expression("Plot[Sin[x], {x, 0, 2 Pi}]") rasterize_expression("MatrixForm[{{1, 2}, {3, 4}}]") rasterize_expression("Graphics[Circle[]]", image_size=200)

Select a cell in the notebook (moves cursor to it).

Scroll the notebook view to make a cell visible.

Export a notebook to PDF, HTML, TeX, or Markdown.

Verify a sequence of mathematical expressions steps.

Get current Wolfram kernel session state (memory, uptime, version).

Load a Mathematica package (e.g., "Developer`").

List all currently loaded packages and contexts.

List all user-defined variables in the current Mathematica kernel session.

Get detailed information about a specific variable.

Set a variable in the Mathematica kernel session.

Args: name: Variable name (e.g., "x", "myData") value: Wolfram Language expression to assign (e.g., "5", "{1,2,3}", "Plot[Sin[x],{x,0,Pi}]")

Returns: Confirmation with the assigned value

Example: set_variable("x", "Range[10]") -> {success: true, value: "{1,2,3,4,5,6,7,8,9,10}"}

Clear variables from the Mathematica kernel session.

Equivalent to Python's 'del' or clearing notebook state.

Args: names: Specific variable names to clear (e.g., ["x", "y", "z"]) pattern: Wolfram pattern to match (e.g., "temp*" clears temp1, temp2, etc.) clear_all: If True, clear ALL Global` variables (use with caution!)

Returns: List of cleared variables

Example: clear_variables(names=["x", "y"]) -> {cleared: ["x", "y"], count: 2} clear_variables(pattern="temp*") -> {cleared: ["temp1", "temp2"], count: 2}

Get detailed structural information about a Wolfram expression.

Like Python's type() on steroids - shows Head, FullForm, tree structure, depth, leaf count, and type checks (NumericQ, ListQ, etc.)

Args: expression: Wolfram Language expression to analyze

Returns: Structural information: head, full form, depth, leaf count, type flags

Example: get_expression_info("{{1,2},{3,4}}") -> {head: "List", depth: 3, dimensions: [2,2]} get_expression_info("Sin[x] + Cos[x]") -> {head: "Plus", leaf_count: 3}

Get recent Mathematica messages/warnings from the session.

Like Python's exception traceback - helps debug what went wrong. Includes recently captured evaluation and dispatch-level messages.

Args: count: Number of recent messages to retrieve (default 10)

Returns: List of recent messages with timestamps

Example: After a failed computation: get_messages() -> [{timestamp: "...", message: "Power::infy: Infinite expression 1/0 encountered."}]

Restart the Mathematica kernel, clearing all state.

This is the nuclear option - clears all variables, definitions, and state. Use when the kernel is in a bad state or you need a fresh start.

Returns: Confirmation of kernel restart

Open an existing Mathematica notebook file (.nb) in the Mathematica frontend.

Supports:

• Absolute paths: /Users/foo/notebook.nb

• Home-relative paths: ~/Documents/notebook.nb

• Relative paths (resolved from current directory)

Args: path: Path to the .nb file

Returns: Notebook ID and metadata for use with other notebook commands

Example: open_notebook_file("~/Documents/analysis.nb") -> {id: "NotebookObject[...]", cell_count: 15}

Execute a Wolfram Language script file (.wl, .m) and return the result.

This is equivalent to Get[path] - loads and executes the script in the current kernel session. Any definitions or side effects persist.

Args: path: Path to the .wl or .m script file

Returns: The result of the last expression in the script, plus timing info

Example: run_script("~/scripts/setup.wl") -> {result: "Null", timing_ms: 150}

[LEGACY] Read notebook content as structured text.

Prefer read_notebook() unless you specifically need this older or narrower workflow.

[LEGACY] Convert a notebook into markdown, LaTeX, plain text, or Wolfram code.

Prefer read_notebook() unless you specifically need this older or narrower workflow.

[LEGACY] Get the notebook's section outline.

Prefer read_notebook() unless you specifically need this older or narrower workflow.

[LEGACY] Parse a notebook with the Python-native parser.

Prefer read_notebook() unless you specifically need this older or narrower workflow.

[LEGACY] Read a single notebook cell by index.

Prefer read_notebook() unless you specifically need this older or narrower workflow.

[PRIMARY] Read a Mathematica notebook with backend-aware dispatch.

Prefer this over read_notebook_content, convert_notebook, get_notebook_outline, parse_notebook_python, and get_notebook_cell unless you need a specific legacy backend or narrow low-level operation.

Query Wolfram Alpha with natural language.

This gives Mathematica superpowers - ask questions in plain English and get computed answers, data, and more.

Args: query: Natural language question (e.g., "population of France", "integrate x^2 from 0 to 1", "weather in Tokyo") return_type: - "result": Simple text result (default) - "data": Structured data when available - "full": All available pods/information

Returns: Wolfram Alpha response in requested format

Example: wolfram_alpha("population of Tokyo") -> "13.96 million people (2021)" wolfram_alpha("derivative of sin(x^2)", "data") -> {result: "2 x cos(x^2)"}

Convert natural language mathematical description to Wolfram Language code.

This is magic - describe what you want in English and get executable code.

Args: text: Natural language description (e.g., "the integral of x squared from 0 to 1", "solve x squared equals 4 for x", "plot sine of x from 0 to 2 pi")

Returns: Wolfram Language code and its evaluation result

Example: interpret_natural_language("the derivative of e to the x") -> {code: "D[E^x, x]", result: "E^x"}

Look up real-world entity data from Wolfram's curated knowledge base.

Entity types include: "Country", "City", "Chemical", "Planet", "Company", "Person", "Movie", "University", "Element", "Star", and many more.

Args: entity_type: Type of entity (e.g., "Country", "City", "Chemical") name: Name to look up (e.g., "France", "Tokyo", "Water") properties: Specific properties to retrieve (default: common properties)

Returns: Entity data with requested properties

Example: entity_lookup("Country", "Japan", ["Population", "Capital", "GDP"]) -> {name: "Japan", Population: "125.8 million", Capital: "Tokyo", GDP: "$4.94 trillion"}

Convert between units using Wolfram's comprehensive unit system.

Args: quantity: Value with unit (e.g., "5 miles", "100 kg", "25 Celsius") target_unit: Target unit (e.g., "kilometers", "pounds", "Fahrenheit")

Returns: Converted quantity

Example: convert_units("100 kilometers", "miles") -> "62.1371 miles" convert_units("0 Celsius", "Fahrenheit") -> "32 Fahrenheit"

Get a physical or mathematical constant.

Args: name: Constant name (e.g., "SpeedOfLight", "PlanckConstant", "Pi", "EulerGamma", "GoldenRatio", "Avogadro")

Returns: Constant value with unit (if applicable) and numeric approximation

Example: get_constant("SpeedOfLight") -> {value: "299792458 m/s", numeric: "2.998e8"}

Trace the step-by-step evaluation of an expression.

Time the evaluation of an expression with memory tracking.

Validate Wolfram Language code syntax without executing it.

Import data from a file or URL into Mathematica.

Export data or graphics to a file.

List all supported import/export formats.

Analyze the structure of a graphics object.

Export a graphics expression to an image file.

Generate a side-by-side comparison of multiple plots.

Create an animation by varying a parameter.

Get the status of all feature flags.

Get recent computation history: code previews, outputs, timing, success status.

Clear the computation journal.

Search for Wolfram Language functions and optionally auto-execute.

Get comprehensive information about a Wolfram Language symbol.

Find Wolfram functions similar to a query using fuzzy matching.

Compute integral using Integrate.

Solve an equation using Solve.

Simplify a mathematical expression.

Compute derivative using D.

Expand a mathematical expression.

Factor a mathematical expression.

Compute limit using Limit.

Compute Taylor/power series expansion.

Search the Wolfram Function Repository.

Get details about a Wolfram Function Repository function.

Load a function from the Wolfram Function Repository.

Search the Wolfram Data Repository.

Get detailed information about a Wolfram Data Repository dataset.

Load a dataset from the Wolfram Data Repository.

Submit a long-running computation for background execution.

Check the status of a submitted computation.

Retrieve the result of a completed computation.

Evaluate and cache a Wolfram expression for later reuse.

Retrieve a previously cached expression result.

List all cached expressions with their metadata.

Clear all cached expressions.