{"id":18997,"date":"2025-12-10T09:22:17","date_gmt":"2025-12-10T14:22:17","guid":{"rendered":"https:\/\/blogs.mathworks.com\/deep-learning\/?p=18997"},"modified":"2025-12-10T09:41:02","modified_gmt":"2025-12-10T14:41:02","slug":"matlab-mcp-client-on-github","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/deep-learning\/2025\/12\/10\/matlab-mcp-client-on-github\/","title":{"rendered":"MATLAB MCP Client is out on GitHub now!"},"content":{"rendered":"
<\/h6>\r\n
<\/h6>\r\n\r\n\r\n\r\n
\"\"<\/td>\r\nGuest Writer: Shweta Pujari<\/a><\/strong>\r\n
<\/h6>\r\nShweta Pujari is the Product Manager for AI and GenAI. In this blog post, she joins me to demonstrate how to use the new MATLAB MCP Client to build agentic workflows in the MATLAB language.<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
<\/h6>\r\nMathWorks has released a new capability on GitHub \u2013 the MATLAB MCP Client \u2013 enabling users to easily connect MATLAB-based AI workflows to external services and third-party tools (via HTTP).\r\n
<\/h6>\r\nhttps:\/\/github.com\/matlab-deep-learning\/mcpHTTPClient<\/a>\r\n
<\/h6>\r\n
<\/h6>\r\nNote:<\/em> About a month earlier, MathWorks also released the MATLAB MCP Core Server<\/a> on GitHub, which provides a reference MCP implementation for calling MATLAB from third party AI chats and agents.\r\n
<\/h6>\r\n
<\/h6>\r\nIn this post, we\u2019ll break down what the MCP client is, how it works, and why it\u2019s a big deal for engineers building AI solutions in MATLAB.\r\n
<\/h6>\r\n
<\/h6>\r\n
<\/h6>\r\n

What is the MATLAB MCP Client?<\/h2>\r\n

<\/h6>\r\nModel Context Protocol (MCP)<\/strong> is an emerging standard that defines how AI models communicate with external tools and services. Think of MCP as a language that both an AI model and a tool server understand \u2013 it covers how to list what tools are available and how to invoke those tools with specific inputs, getting back results in a structured way. Many advanced LLM applications today use agents that can call external functions (for example, an AI assistant that calls a weather API or database query). MCP provides a formal framework for this kind of tool calling so that any AI client can talk to any tool server that speaks MCP.\r\n
<\/h6>\r\nWith this capability, you can implement an MCP client entirely in MATLAB code. In practical terms, this add-on allows MATLAB to connect to an MCP-compatible server over HTTP and use the tools that server offers. Once connected, MATLAB can list the available tools on that server and then call those tools on demand. Importantly, this integration is designed to work hand-in-hand with the Large Language Models (LLMs) with MATLAB<\/a> add-on, enabling the language model to automatically decide when to use these tools as needed.\r\n
<\/h6>\r\n
<\/h6>\r\n
<\/h6>\r\n\"\"\r\n
<\/h6>\r\n
<\/h6>\r\n

Key capabilities of the MATLAB MCP Client<\/h2>\r\n

<\/h6>\r\n
    \r\n \t
  1. Connecting to Tools via MCP Servers: <\/strong>You can create an MCP client in MATLAB that connects to any streamable HTTP MCP server by specifying its URL (endpoint). Upon connection, the client automatically fetches the list of available tools from the server. This means MATLAB instantly knows what functions the server can perform (e.g., \u201cget_weather\u201d, \u201crun_simulation\u201d, \u201cquery_database\u201d, etc.), along with details about each tool\u2019s inputs and outputs.<\/li>\r\n \t
  2. Calling External Tools: <\/strong>With the MCP client, calling an external tool becomes as straightforward as calling a local MATLAB function. The add-on provides a high-level function callTool <\/em>for this purpose. You simply pass in the tool name and required parameters, and callTool <\/em>handles the communication with the server, returning the result to MATLAB. There\u2019s no need to manually craft HTTP requests or parse JSON \u2013 the client does that behind the scenes. This dramatically simplifies integration with external APIs or services.<\/li>\r\n \t
  3. Integrating with LLM Workflows: <\/strong>Perhaps the most exciting capability is enabling \u201cagentic\u201d <\/strong>AI workflows. By combining this MCP client with the LLMs with MATLAB add-on, you allow a large language model in MATLAB to autonomously decide when to call an external tool to fulfill a user\u2019s request. The MCP client exposes the server\u2019s tools to the LLM: you convert the list of tools into a form the model understands (openAIFunction <\/em>objects for OpenAI\u2019s function-calling interface) and pass them into your LLM session. Then, when you prompt the LLM, it can choose to output a tool call (including the tool name and arguments) if it determines that using a tool is the best way to get the answer. MATLAB captures this intended function call, and you can execute it via callTool(client, toolRequest) <\/em>to get the result. In short, the MCP client makes it possible for an AI assistant in MATLAB to not just talk about external data or actions, but to actually perform those actions by invoking real services.<\/li>\r\n<\/ol>\r\n
    <\/h6>\r\n
    <\/h6>\r\n
    <\/h6>\r\n

    Get started with the MATLAB MCP client<\/h2>\r\n
    This example demonstrates how to easily build an MCP Client in MATLAB to connect with an MCP server and use an LLM to call the server tools. It uses a single tool from a\u00a0prime sequence MCP server<\/a>.<\/div>\r\n \r\n\r\n \r\n

    Set-up the interface to call OpenAI LLMs<\/h3>\r\n
    Make sure you get the latest version of the LLM-with-MATLAB<\/a> repo:<\/div>\r\n
    \r\n
    <\/h6>\r\n
    Create a .env file with your OPENAI_API_KEY<\/div>\r\n
    \r\n
    OPENAI_API_KEY=sk-proj-xxxxx<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    <\/h6>\r\n
    \r\n
    gitclone(\"https:\/\/github.com\/matlab-deep-learning\/llms-with-matlab\")\r\naddpath(\"llms-with-matlab\")\r\nloadenv '.env'\r\n<\/pre>\r\n<\/div>\r\n<\/div>\r\n
    <\/h6>\r\n \r\n
    Build the MCP client<\/h3>\r\n
    Here is how you can connect to the MCP server endpoint from MATLAB:<\/div>\r\n
    <\/h6>\r\n
    \r\n
    endpoint = \"https:\/\/production-server-demo.mathworks-workshop.com\/primeSequence\/mcp\";\r\nclient = mcpHTTPClient(endpoint)\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    client = \r\n  mcpHTTPClient with properties:\r\n\r\n       Endpoint: \"https:\/\/production-server-demo.mathworks-workshop.com\/primeSequence\/mcp\"\r\n    ServerTools: {[1\u00d71 struct]}\r\n<\/pre>\r\n
    <\/h6>\r\n
    <\/h6>\r\n
    The first step is to discover the tools made available by the MCP server. You can loop to list them all. Here there is only one:<\/div>\r\n
    \r\n
    <\/div>\r\n<\/div>\r\n
    <\/h6>\r\n
    \r\n
    serverTools = client.ServerTools;\r\nfor i = 1:length(serverTools)\r\n    disp(serverTools{i}.name)\r\n    disp(serverTools{i}.description)\r\n    disp('---')\r\nend\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
     \r\nprimeSequence\r\nReturn the first N primes of the given sequence type. Four sequence types supported: Eisenstein, Balanced, Isolated and Gaussian.\r\n---\r\n<\/pre>\r\n
    <\/h6>\r\n
    <\/h6>\r\n
    Next step is to look up the arguments required to call a tool.<\/div>\r\n
    <\/h6>\r\n
    \r\n
    tool1 = serverTools{1};\r\ntoolName = tool1.name;\r\nclient.ServerTools{1}.inputSchema\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\nThe input schema informs which arguments or properties are required:\r\n
    <\/h6>\r\n
    \r\n
    client.ServerTools{1}.inputSchema.properties<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    ans = struct with fields:\r\n       n: [1\u00d71 struct]\r\n    type: [1\u00d71 struct]\r\n<\/pre>\r\n
    <\/h6>\r\n
    \r\n
    client.ServerTools{1}.inputSchema.properties.n\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    ans = struct with fields:\r\n           type: 'number'\r\n    description: 'Length of the generated sequence'\r\n<\/pre>\r\n
    <\/h6>\r\n
    \r\n
    client.ServerTools{1}.inputSchema.properties.type<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    ans = struct with fields:\r\n           type: 'string'\r\n    description: 'Name of the sequence to generate'\r\n<\/pre>\r\n
    <\/h6>\r\n
    \r\n
    client.ServerTools{1}.inputSchema.required<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    ans = 2\u00d71 cell array\r\n'n'       \r\n'type'    \r\n<\/pre>\r\n
    <\/h6>\r\n
    <\/h6>\r\n \r\n
    Integrate the MCP client to the model<\/h3>\r\n
    The following functions are provided by the LLMs with MATLAB repo. In this example, the OpenAI service is used to provide the Large Language Model.<\/div>\r\n
    <\/div>\r\n
    \r\n
    \r\n
    <\/h6>\r\n
    \r\n
    f = openAIFunction(serverTools)<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    f = \r\n  openAIFunction with properties:\r\n\r\n    FunctionName: \"primeSequence\"\r\n     Description: \"Return the first N primes of the given sequence type. Four sequence types supported: Eisenstein, Balanced, Isolated and Gaussian.\"\r\n      Parameters: [1\u00d71 struct]\r\n<\/pre>\r\n<\/div>\r\n<\/div>\r\n
    <\/h6>\r\n
    \r\n
    <\/h6>\r\n
    \r\n
    model = openAIChat(Model=\"gpt-5-mini\",Tools=f)<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    model = \r\n  openAIChat with properties:\r\n\r\n           ModelName: \"gpt-5-mini\"\r\n         Temperature: 1\r\n                TopP: 1\r\n       StopSequences: [0\u00d70 string]\r\n             TimeOut: 10\r\n        SystemPrompt: []\r\n      ResponseFormat: \"text\"\r\n     PresencePenalty: 0\r\n    FrequencyPenalty: 0\r\n       FunctionNames: \"primeSequence\"\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    <\/h6>\r\nLet the model select which tool to call. Here there is only one tool to choose from:\r\n
    <\/h6>\r\n
    \r\n
    \r\n
    [~,completeOutput] = generate(model,\"generate a sequence of 10 prime numbers\")<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    completeOutput = struct with fields:\r\n           role: 'assistant'\r\n        content: []\r\n     tool_calls: [1\u00d71 struct]\r\n        refusal: []\r\n    annotations: []\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    \r\n
    <\/h6>\r\n
    \r\n
    completeOutput.tool_calls<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    ans = struct with fields:\r\n          id: 'call_5TOPVJ5zftW3WWydHQ0fmpyR'\r\n        type: 'function'\r\n    function: [1\u00d71 struct]\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    <\/h6>\r\nNow just integrate this logic in an agentic loop:\r\n
    \r\n
    \r\n
    toolRequest = completeOutput.tool_calls(1).function<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    toolRequest = struct with fields:\r\n         name: 'primeSequence'\r\n    arguments: '{\"n\":10,\"type\":\"Eisenstein\"}'\r\n<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    \r\n
    <\/h6>\r\n
    \r\n
    output = callTool(client,toolRequest)<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n
    output = \"[2,5,11,17,23,29,41,47,53,59]\"<\/pre>\r\n<\/div>\r\n
    <\/h6>\r\n \r\n
    <\/h6>\r\nIf you want to see this workflow in action, watch this video to see how you can create an MCP client in MATLAB and use LLMs to call tools from the connected MCP server.\r\n\r\n \r\n
    <\/h6>\r\n