The MATLAB MCP Server integrates MATLAB with AI to enable:
Execute MATLAB code: Run commands or scripts and view the output directly in your conversation
Generate MATLAB code from natural language: Describe what you want to accomplish in plain language
Access MATLAB documentation: Use URIs like matlab://documentation/getting-started
Save scripts: Optionally save executed or generated MATLAB scripts for future reference
Integration with AI tools: Use seamlessly with AI assistants like Claude Desktop
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MATLAB MCP Server plot a sine wave from 0 to 2π"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Related MCP server: MATLAB MCP Tool
Access MATLAB documentation via matlab://documentation/getting-started URI
Get started guide with examples and usage instructions
execute_matlab_code - Execute MATLAB code and get results
Run any MATLAB commands or scripts
Option to save scripts for future reference
View output directly in your conversation
generate_matlab_code - Generate MATLAB code from natural language
Describe what you want to accomplish in plain language
Get executable MATLAB code in response
Option to save generated scripts
Install dependencies:
npm installBuild the server:
npm run buildFor development with auto-rebuild:
npm run watchMATLAB installed on your system
Node.js (v14 or higher)
To install MATLAB MCP Server for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @WilliamCloudQi/matlab-mcp-server --client claudenpm install -g matlab-mcp-serverOr clone the repository and build it yourself:
git clone https://github.com/username/matlab-mcp-server.git
cd matlab-mcp-server
npm install
npm run buildTo use with cline , add the server config:
On MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json
On Windows: %APPDATA%/Claude/claude_desktop_config.json
{
"mcpServers": {
"matlab-server": {
"command": "node",
"args": ["/path/to/matlab-server/build/index.js"],
"env": {
"MATLAB_PATH": "/path/to/matlab/executable"
},
"disabled": false,
"autoApprove": []
}
}
}Replace /path/to/matlab/executable with the path to your MATLAB executable:
Windows: Usually C:\\Program Files\\MATLAB\\R2023b\\bin\\matlab.exe
macOS: Usually /Applications/MATLAB_R2023b.app/bin/matlab
Linux: Usually /usr/local/MATLAB/R2023b/bin/matlab
Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the MCP Inspector, which is available as a package script:
npm run inspectorThe Inspector will provide a URL to access debugging tools in your browser.
Execute MATLAB code and return the results
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | MATLAB code to execute | |
| saveScript | No | Whether to save the MATLAB script for future reference | |
| scriptPath | No | Custom path to save the MATLAB script (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool executes code and returns results, but lacks critical details such as execution environment (e.g., sandboxed, local MATLAB instance), safety considerations (e.g., code injection risks), performance traits (e.g., timeout limits), or error handling. This leaves significant gaps for an agent to understand how the tool behaves beyond its basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of a single sentence that directly states the tool's core function. There is no wasted language or redundancy, making it efficient for an agent to parse. Every word earns its place by conveying essential information without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of executing code (a potentially risky operation) and the lack of annotations and output schema, the description is insufficiently complete. It doesn't address critical context like execution safety, result format, error conditions, or dependencies. For a tool with no structured safety or output information, the description should provide more guidance to help an agent use it effectively and safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting all three parameters. The description adds no additional parameter semantics beyond what the schema provides, such as code syntax requirements or path formatting. However, with high schema coverage, the baseline score of 3 is appropriate, as the schema adequately handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Execute') and resource ('MATLAB code'), making it immediately understandable. It distinguishes from the sibling tool 'generate_matlab_code' by focusing on execution rather than generation. However, it doesn't specify what kind of results are returned or the execution environment, keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention the sibling tool 'generate_matlab_code' or any other potential tools, nor does it specify prerequisites, execution context, or limitations. The agent must infer usage based solely on the tool name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate MATLAB code from a natural language description
| Name | Required | Description | Default |
|---|---|---|---|
| description | Yes | Natural language description of what the code should do | |
| saveScript | No | Whether to save the generated MATLAB script | |
| scriptPath | No | Custom path to save the MATLAB script (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical behavioral details: it doesn't mention whether the generated code is saved by default, what format or quality the output is in, any limitations (e.g., complexity, length), or error handling. For a code generation tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero waste. It's front-loaded with the core purpose and appropriately sized for a straightforward tool. Every word earns its place, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of code generation (a non-trivial task), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., code string, file path, errors), any constraints on the input description, or how the saveScript and scriptPath parameters interact. The agent is left with significant gaps in understanding the tool's behavior and output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (description, saveScript, scriptPath) with clear descriptions. The tool description adds no parameter-specific information beyond what's in the schema. According to the rules, with high schema coverage (>80%), the baseline is 3 even with no param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate MATLAB code from a natural language description.' It specifies the verb ('generate'), resource ('MATLAB code'), and input source ('natural language description'). However, it doesn't explicitly differentiate from its sibling tool 'execute_matlab_code' (which runs code vs. generating it), so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There's no mention of the sibling tool 'execute_matlab_code' or any other context for choosing between generating code and executing it. The agent must infer usage from the tool name alone, which is insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The two tools have clearly distinct purposes: one executes existing MATLAB code, while the other generates new code from natural language. There is no overlap or ambiguity between these functions, making it easy for an agent to select the correct tool based on the task.
Both tool names follow a consistent verb_noun pattern (execute_matlab_code and generate_matlab_code), using the same verb style and snake_case formatting. This predictability aids in understanding and usage without any deviations.
With only two tools, the server feels thin for a MATLAB domain, which typically involves more operations like plotting, data analysis, or file management. While the tools cover core execution and generation, the scope is limited and may not support complex agent workflows effectively.
The tool set is severely incomplete for a MATLAB server, lacking essential operations such as loading/saving data, creating plots, debugging code, or managing variables. Agents will face significant gaps when trying to perform common MATLAB tasks beyond basic code execution and generation.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Connect AI assistants to GitHub - manage repos, issues, PRs, and workflows through natural language.
Connect AI assistants to your GitHub-hosted Obsidian vault to seamlessly access, search, and analy…
Create and manage AI agents that collaborate and solve problems through natural language interacti…
Give your AI agents the tools to build, manage, and run automation workflows.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/WilliamCloudQi/matlab-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
