\n
Hey there, everyone, and welcome to the latest installment of \u201cHank shares his AI journey.\u201d \ud83d\ude42 Artificial Intelligence (AI) continues to be all the rage, and coming back from Cisco Live in San Diego, I was excited to dive into the world of agentic AI.<\/p>\n
With announcements like Cisco\u2019s\u00a0own agentic AI solution,\u00a0AI Canvas, as well as discussions with partners and other engineers about this next phase of AI possibilities, my curiosity was piqued<\/span>:\u00a0What does this all mean for us<\/em><\/span>\u00a0network engineers? Moreover, how can we start to experiment and learn about agentic AI?<\/em><\/p>\nI began my exploration of the topic of agentic AI, reading and watching a wide range of content to gain a deeper understanding of the subject. I won\u2019t delve into a detailed definition in this blog, but here are the basics of how I think about it:<\/p>\n
Agentic AI is a vision for a world where AI doesn\u2019t just answer questions we ask, but it begins to work more independently.<\/strong> Driven by the goals we set, and utilizing access to tools and systems we provide, an agentic AI solution can monitor the current state of the network and take actions to ensure our network operates exactly as intended.<\/p>\nSounds pretty darn futuristic, right?\u00a0Let\u2019s dive into the technical aspects of how it works\u2014roll up your sleeves, get into the lab, and let\u2019s learn some new things.<\/p>\n
What are AI \u201ctools?\u201d<\/strong><\/h2>\nThe first thing I wanted to explore and better understand was the concept of \u201ctools\u201d within this agentic framework. As you may recall, the LLM (large language model) that powers AI systems is essentially an algorithm trained on vast amounts of data. An LLM can \u201cunderstand\u201d your questions and instructions. On its own<\/em>, however, the LLM is limited to the data it was trained on. It can\u2019t even search the web for current movie showtimes without some \u201ctool\u201d allowing it to perform a web search.<\/p>\nFrom the very early days of the GenAI buzz, developers have been building and adding \u201ctools\u201d into AI applications. Initially, the creation of these tools was ad hoc and varied depending on the developer, LLM, programming language, and the tool\u2019s goal.\u00a0 But recently, a new framework for building AI tools has gotten a lot of excitement and is starting to become a new \u201cstandard\u201d for tool development.<\/p>\n
This framework is known as the Model Context Protocol (MCP). Originally developed by Anthropic, the company behind Claude, any developer to use MCP to build tools, called \u201cMCP Servers,\u201d and any AI platform can act as an \u201cMCP Client\u201d to use these tools. It\u2019s essential to remember that we are still in the very early days of AI and AgenticAI; however, currently, MCP appears to be the<\/span> approach for tool building. So I figured I\u2019d dig in and figure out how MCP works by building my own very basic NetAI Agent<\/em>.<\/p>\nI\u2019m far from the first networking engineer to want to dive into this space, so I started by reading a couple of very helpful blog posts by my buddy Kareem Iskander, Head of Technical Advocacy in Learn with Cisco.<\/p>\n
These gave me a jumpstart on the key topics, and Kareem was helpful enough to provide some example code for creating an MCP server. I was ready to explore more on my own.<\/p>\n
Creating a local NetAI playground lab<\/strong><\/h2>\nThere is no shortage of AI tools and platforms today. There is ChatGPT, Claude, Mistral, Gemini, and so many more. Indeed, I utilize many of them regularly for various AI tasks. However, for experimenting with agentic AI and AI tools, I wanted something that was 100% local and didn\u2019t rely on a cloud-connected service.<\/p>\n
A primary reason for this desire was that I wanted to ensure all of my AI interactions remained entirely on my computer and within my network. I knew I would be experimenting in an entirely new area of development. I was also going to send data about \u201cmy network\u201d to the LLM for processing. And while I\u2019ll be using non-production lab systems for all the testing, I still didn\u2019t like the idea of leveraging cloud-based AI systems. I would feel freer to learn and make mistakes if I knew the risk was low. Yes, low<\/em>\u2026 Nothing is completely risk-free.<\/p>\nLuckily, this wasn\u2019t the first time I considered local LLM work, and I had a couple of possible options ready to go. The first is Ollama, a powerful open-source engine for running LLMs locally, or at least on your own server.\u00a0 The second is LMStudio, and while not itself open source, it has an open source foundation, and it is free to use for both personal and \u201cat work\u201d experimentation with AI models. When I read a recent blog by LMStudio about MCP support now being included, I decided to give it a try for my experimentation.<\/p>\nCreating Mr Packets with LMStudio<\/figcaption><\/figure>\nLMStudio is a client for running LLMs, but it isn\u2019t an LLM itself.\u00a0 It provides access to a large number of LLMs available for download and running. With so many LLM options available, it can be overwhelming when you get started. The key things for this blog post and demonstration are that you need a model that has been trained for \u201ctool use.\u201d Not all models are. And furthermore, not all \u201ctool-using\u201d models actually work with tools. For this demonstration, I\u2019m using the google\/gemma-2-9b model. It\u2019s an \u201copen model\u201d built using the same research and tooling behind Gemini.<\/em><\/p>\nThe next thing I needed for my experimentation was an initial idea for a tool to build. After some thought, I decided a good \u201chello world\u201d for my new NetAI project would be a way for AI to send and process \u201cshow commands\u201d from a network device. I chose pyATS to be my NetDevOps library of choice for this project. In addition to being a library that I\u2019m very familiar with, it has the benefit of automatic output processing into JSON through the library of parsers included in pyATS. I could also, within just a couple of minutes, generate a basic Python function to send a show command to a network device and return the output as a starting point.<\/p>\n
Here\u2019s that code:<\/p>\n
def send_show_command(
\n command: str,
\n device_name: str,
\n username: str,
\n password: str,
\n ip_address: str,
\n ssh_port: int = 22,
\n network_os: Optional[str] = \"ios\",
\n) -> Optional[Dict[str, Any]]:
\n
\n # Structure a dictionary for the device configuration that can be loaded by PyATS
\n device_dict = {
\n \"devices\": {
\n device_name: {
\n \"os\": network_os,
\n \"credentials\": {
\n \"default\": {\"username\": username, \"password\": password}
\n },
\n \"connections\": {
\n \"ssh\": {\"protocol\": \"ssh\", \"ip\": ip_address, \"port\": ssh_port}
\n },
\n }
\n }
\n }
\n testbed = load(device_dict)
\n device = testbed.devices[device_name]
\n
\n device.connect()
\n output = device.parse(command)
\n device.disconnect()
\n
\n return output
\n<\/pre>\nBetween Kareem\u2019s blog posts and the getting-started guide for FastMCP 2.0, I learned it was frighteningly easy<\/em> to convert my function into an MCP Server\/Tool. I just needed to add five lines of code.<\/p>\nfrom fastmcp import FastMCP
\n
\nmcp = FastMCP(\"NetAI Hello World\")
\n
\n@mcp.tool()
\ndef send_show_command()
\n .
\n .
\n
\n
\nif __name__ == \"__main__\":
\n mcp.run()
\n<\/pre>\nWell.. it was ALMOST that easy. I did <\/em>have to make a few adjustments to the above basics to get it to run successfully. You can see the full working copy of the code\u00a0in my newly created NetAI-Learning project on GitHub.<\/p>\nAs for those few adjustments, the changes I made were:<\/p>\n
\nA nice, detailed docstring for the function behind the tool. MCP clients use the details from the docstring to understand how and why to use the tool.<\/li>\n After some experimentation, I opted to use \u201chttp\u201d transport for the MCP server rather than the default and more common \u201cSTDIO.\u201d The reason I went this way was to prepare for the next phase of my experimentation, when my pyATS MCP server would likely run within the network lab environment itself, rather than on my laptop. STDIO requires the MCP Client and Server to run on the same host system.<\/li>\n<\/ul>\nSo I fired up the MCP Server, hoping that there wouldn\u2019t be any errors. (Okay, to be honest, it took a couple of iterations<\/em> in development to get it working without errors\u2026 but I\u2019m doing this blog post \u201ccooking show style,\u201d where the boring work along the way is hidden. \ud83d\ude09<\/p>\npython netai-mcp-hello-world.py
\n
\n\u256d\u2500 FastMCP 2.0 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256e
\n\u2502 \u2502
\n\u2502 _ __ ___ ______ __ __ _____________ ____ ____ \u2502
\n\u2502 _ __ ___ \/ ____\/___ ______\/ \/_\/ |\/ \/ ____\/ __ |___ \/ __ \u2502
\n\u2502 _ __ ___ \/ \/_ \/ __ `\/ ___\/ __\/ \/|_\/ \/ \/ \/ \/_\/ \/ ___\/ \/ \/ \/ \/ \/ \u2502
\n\u2502 _ __ ___ \/ __\/ \/ \/_\/ (__ ) \/_\/ \/ \/ \/ \/___\/ ____\/ \/ __\/_\/ \/_\/ \/ \u2502
\n\u2502 _ __ ___ \/_\/ __,_\/____\/__\/_\/ \/_\/____\/_\/ \/_____(_)____\/ \u2502
\n\u2502 \u2502
\n\u2502 \u2502
\n\u2502 \u2502
\n\u2502 \ud83d\udda5\ufe0f Server name: FastMCP \u2502
\n\u2502 \ud83d\udce6 Transport: Streamable-HTTP \u2502
\n\u2502 \ud83d\udd17 Server URL: http:\/\/127.0.0.1:8002\/mcp\/ \u2502
\n\u2502 \u2502
\n\u2502 \ud83d\udcda Docs: https:\/\/gofastmcp.com \u2502
\n\u2502 \ud83d\ude80 Deploy: https:\/\/fastmcp.cloud \u2502
\n\u2502 \u2502
\n\u2502 \ud83c\udfce\ufe0f FastMCP version: 2.10.5 \u2502
\n\u2502 \ud83e\udd1d MCP version: 1.11.0 \u2502
\n\u2502 \u2502
\n\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256f
\n
\n
\n[07\/18\/25 14:03:53] INFO Starting MCP server 'FastMCP' with transport 'http' on http:\/\/127.0.0.1:8002\/mcp\/server.py:1448
\nINFO: Started server process [63417]
\nINFO: Waiting for application startup.
\nINFO: Application startup complete.
\nINFO: Uvicorn running on http:\/\/127.0.0.1:8002 (Press CTRL+C to quit)
\n<\/pre>\nThe next step was to configure LMStudio to act as the MCP Client and connect to the server to have access to the new \u201csend_show_command\u201d tool. While not \u201cstandardized, \u201cmost MCP Clients use a very common JSON configuration to define the servers. LMStudio is one of these clients.<\/p>\nAdding the pyATS MCP server to LMStudio<\/figcaption><\/figure>\nWait\u2026 if you\u2019re wondering, \u2018Where\u2019s the network, Hank? What device are you sending the \u2018show commands\u2019 to?\u2019 <\/em>No worries, my inquisitive friend: I created a very simple Cisco Modeling Labs (CML) topology with a couple of IOL devices configured for direct SSH access using the PATty feature.<\/p>\nNetAI Hello World CML Network<\/figcaption><\/figure>\nLet\u2019s see it in action!<\/strong><\/h2>\nOkay, I\u2019m sure you are ready to see it in action.\u00a0 I know I sure was as I was building it.\u00a0 So let\u2019s do it!<\/p>\n
To start, I instructed the LLM on how to connect to my network devices in the initial message.<\/p>\nTelling the LLM about my devices<\/figcaption><\/figure>\nI did this because the pyATS tool needs the address and credential information for the devices.\u00a0 In the future I\u2019d like to look at the MCP servers for different source of truth options like NetBox and Vault so it can \u201clook them up\u201d as needed.\u00a0 But for now, we\u2019ll start simple.<\/p>\n
First question: Let\u2019s ask about software version info.<\/p>\n
You can see the details of the tool call by diving into the input\/output screen.<\/p>\n
This is pretty cool, but what exactly is happening here? Let\u2019s walk through the steps involved.<\/p>\n
\nThe LLM client starts and queries the configured MCP servers to discover the tools available.<\/li>\n I send a \u201cprompt\u201d to the LLM to consider.<\/li>\n The LLM processes my prompts. It \u201cconsiders\u201d the different tools available and if they might be relevant as part of building a response to the prompt.<\/li>\n The LLM determines that the \u201csend_show_command\u201d tool is relevant to the prompt and builds a proper payload to call the tool.<\/li>\n The LLM invokes the tool with the proper arguments from the prompt.<\/li>\n The MCP server processes the called request from the LLM and returns the result.<\/li>\n The LLM takes the returned results, along with the original prompt\/question as the new input to use to generate the response.<\/li>\n The LLM generates and returns a response to the query.<\/li>\n<\/ol>\nThis isn\u2019t all that different from what you might do if you were asked the same question.<\/p>\n
\nYou would consider the question, \u201cWhat software version is router01 running?\u201d<\/li>\n You\u2019d think about the different ways you could get the information needed to answer the question. Your \u201ctools,\u201d so to speak.<\/li>\n You\u2019d decide on a tool and use it to gather the information you needed. Probably SSH to the router and run \u201cshow version.\u201d<\/li>\n You\u2019d review the returned output from the command.<\/li>\n You\u2019d then reply to whoever asked you the question with the proper answer.<\/li>\n<\/ol>\nHopefully, this helps demystify a little about how these \u201cAI Agents\u201d work under the hood.<\/p>\n
How about one more example? Perhaps something a bit more complex than simply \u201cshow version.\u201d Let\u2019s see if the NetAI agent can help identify which switch port the host is connected to by describing the basic process involved.<\/p>\n
Here\u2019s the question\u2014sorry, prompt<\/em>, that I submit to the LLM:<\/p>\nPrompt asking a multi-step question of the LLM.<\/figcaption><\/figure>\nWhat we should notice about this prompt is that it will require the LLM to send and process show commands from two different network devices. Just like with the first example, I do NOT tell the LLM which command to run. I only ask for the information I need. There isn\u2019t a \u201ctool\u201d that knows the IOS commands. That knowledge is part of the LLM\u2019s training data.<\/p>\n
Let\u2019s see how it does with this prompt:<\/p>\nThe LLM successfully executes the multi-step plan.<\/figcaption><\/figure>\nAnd look at that, it was able to handle the multi-step procedure to answer my question.\u00a0 The LLM even explained what commands it was going to run, and how it was going to use the output.\u00a0 And if you scroll back up to the CML network diagram, you\u2019ll see that it correctly identifies interface Ethernet0\/2 as the switch port to which the host was connected.<\/p>\n
So what\u2019s next, Hank?<\/em><\/strong><\/h2>\nHopefully, you found this exploration of agentic AI tool creation and experimentation as interesting as I have. And maybe you\u2019re starting to see the possibilities for your own daily use. If you\u2019d like to try some of this out on your own, you can find everything you need on my netai-learning GitHub project.<\/p>\n
\nThe mcp-pyats code for the MCP Server. You\u2019ll find both the simple \u201chello world\u201d example and a more developed work-in-progress tool that I\u2019m adding additional features to. Feel free to use either.<\/li>\n The CML topology I used for this blog post. Though any network that is SSH reachable will work.<\/li>\n The mcp-server-config.json file that you can reference for configuring LMStudio<\/li>\n A \u201cSystem Prompt Library\u201d where I\u2019ve included the System Prompts for both a basic \u201cMr. Packets\u201d network assistant and the agentic AI tool. These aren\u2019t required for experimenting with NetAI use cases, but System Prompts can be useful to ensure the results you\u2019re after with LLM.<\/li>\n<\/ol>\nA couple of \u201cgotchas\u201d I wanted to share that I encountered during this learning process, which I hope might save you some time:<\/strong><\/h4>\nFirst, not all LLMs that claim to be \u201ctrained for tool use\u201d will work with MCP servers and tools. Or at least the ones I\u2019ve been building and testing. Specifically, I struggled with Llama 3.1 and Phi 4. Both seemed to indicate they were \u201ctool users,\u201d but they failed to call my tools. At first, I thought this was due to my code, but once I switched to Gemma 2, they worked immediately. (I also tested with Qwen3 and had good results.)<\/p>\n
Second, once you add the MCP Server to LMStudio\u2019s \u201cmcp.json\u201d configuration file, LMStudio initiates a connection and maintains an active session. This means that if you stop and restart the MCP server code, the session is broken, giving you an error in LMStudio on your next prompt submission. To fix this issue, you\u2019ll need to either close and restart LMStudio or edit the \u201cmcp.json\u201d file to delete the server, save it, and then re-add it. (There is a bug filed with LMStudio on this problem. Hopefully, they\u2019ll fix it in an upcoming release, but for now, it does make development a bit annoying.)<\/p>\n
As for me, I\u2019ll continue exploring the concept of NetAI and how AI agents and tools can make our lives as network engineers more productive. I\u2019ll be back here with my next blog once I have something new and interesting to share.<\/p>\n
In the meantime, how are you experimenting with agentic AI? Are you excited about the potential? Any suggestions for an LLM that works well with network engineering knowledge? Let me know in the comments below. Talk to you all soon!<\/p>\n
Sign up for\u00a0Cisco U.\u00a0| Join the\u202f\u00a0Cisco Learning Network\u202ftoday for free.<\/p>\n
\n
![\"Retail](\"https:\/\/dmsretail.com\/RetailNews\/wp-content\/uploads\/2022\/05\/RETAIL-ONLINE-TRAINING-728-X-90.png\")
<\/a><\/p>![\"Creating](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-lmstudio-01.jpg\")
![\"Adding](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-lmstudio-02-mcpconfig.jpg\")
![\"NetAI](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-cml-01.jpg\")
![\"Telling](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-lmstudio-03.jpg\")
![\"Short](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-question-01.gif\")
![\"Tool](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-lmstudio-04-command-details.jpg\")
![\"Prompt](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-lmstudio-05-prompt.jpg\")
![\"The](\"https:\/\/storage.googleapis.com\/blogs-images-new\/ciscoblogs\/1\/2025\/07\/netai-lmstudio-06-response.jpg\")