A New Frontier for Network Engineers

Category: Health2025-05-13 15:15:59

When you first hear about MCP — Model Context Protocol, it sounds like something built for hardcore AI researchers. But here’s the reality: Network engineers and automation engineers are going to be some of the biggest users of it.

In case you’re wondering why: MCP is how you make Large Language Models (LLMs) understand your network, your topology, your standards, your world.

Without it? You’re just getting generic ChatGPT answers.

With it? You’re creating Agentic AI that can configure, troubleshoot, and design networks with you.

I have been talking to you — You! …Yes, you! — about network automation and adopting automation in your network engineering for years now. All in all, it’s time to add another brick in *your* wall (of tech tools). In this AI Break, we’ll explore an example that demonstrates the value of using MCP to master automation in today’s AI world.

Okay, so what is MCP?

At its heart, Model Context Protocol is about injecting structured knowledge into an LLM at runtime — automatically and programmatically.

Instead of manually pasting network diagrams or config templates into a chat window, MCP lets your tools tell the model:

What devices are on the network
What standards you use
What technologies you prefer (OSPF over EIGRP, EVPN over VXLAN, whatever)
What change control processes exist

All that context flows into the model, making its responses smarter, more aligned, and more useful for your environment.

Let’s start with a basic, real-world example

Let’s say you’re building an LLM-based Network Assistant that helps generate configs. You don’t want it suggesting RIP when your entire network runs OSPF and BGP.

With MCP, before you even ask the model for a config, you provide AI with the following context:

Look familiar? Yup, it’s a JSON.

{
  "network_standards": {
    "routing_protocols": ["OSPF", "BGP"],
    "preferred_encapsulation": "VXLAN",
    "security_policies": {
      "ssh_required": true,
      "telnet_disabled": true
    }
  },
  "topology": {
    "core_devices": ["core-sw1", "core-sw2"],
    "edge_devices": ["edge-fw1", "edge-fw2"],
    "site_layout": "hub and spoke"
  }
}

Your assistant automatically sends this context to the LLM using MCP, and then asks, “Generate a config to onboard a new site.”

The model now answers in a way that fits your environment— not some random textbook response.

So, what skills do you need to use MCP?

Honestly, a lot of you already have most of what’s needed:

API Fundamentals. You’ll be sending structured context (usually JSON) over API calls — just like RESTCONF, NETCONF, Catalyst Center, Or Meraki APIs.
Understanding your network metadata. You need to know what matters: routing, VLANs, security, device types, and how to represent that as structured data.
Python scripting. You’ll probably use Python to collect this info dynamically (like via Nornir, Netmiko, or native APIs) and then package it into MCP calls.
LLM basics. You need to understand how prompts and context windows work, and how bigger context equals smarter outputs.

The bottom line

MCP isn’t some “maybe later” thing for networkers.

It’s becoming the bridge between your real-world network knowledge and AI’s ability to help you faster, better, and more accurately.

Engineers who know how to feed real context into LLMs will dominate network design, troubleshooting, security auditing, and even full-stack automation.

Start now

Map your network standards.
Package them as JSON.
Play with sending that context into small AI workflows.

The best AI Agents are built by engineers who know their network—and know how to teach it to their AI. Next, let’s get hands-on with MCP!

Try it

For a fully working code and instructions to get started, check out my project on GitHub.

Create a real Model Context Protocol (MCP) server designed for network engineers.

This MCP app does the following:

Serve your network standards (routing protocols, security policies, etc.)
Respond with device health
Connect to Claude Desktop, making your AI assistant aware of your real network environment

And it’s as simple as:

Import the MCP Python SDK
```
from mcp.server.fastmcp import FastMCP
```
Initialize the FastMCP server with a unique name
```
mcp = FastMCP("network-assistant")
```
Define tools.
Tools are a powerful primitive in the Model Context Protocol (MCP). They let your server expose real actions—so the model can query systems, run logic, or kick off workflows. In our use case, we need to define ‘network-standards’ & ‘device status’ functions:
```
@mcp.tool()
async def get_network_standards() -> dict[str, Any]:
    """Returns standard routing protocols, encapsulation, and security policies."""
return NETWORK_STANDARDS
```

Run the server, and you are set!

if __name__ == "__main__":
    mcp.run(transport="stdio")

And if we look at it, this is what the LLM knows about your network before you contextualized it:

And this is after connecting the LLM to our Network:

Where network automation and AI truly collide

You’re no longer scripting for the sake of scripting. And you don’t just use AI for the sake of buzzwords. When you can blend live network state with LLM intelligence, you’re building systems that think, adapt, and assist with you—not just for you.

Start simple. Build one flow.
Make your AI agent actually know your network. Because the future belongs to engineers who don’t just automate—they contextualize.

Welcome to the new frontier of Agentic AI!

Get started with AI

Learning Paths, courses, free tutorials, and more. Unlock the future of technology with artificial intelligence training in Cisco U. Explore AI learning and start building your skills today.

Follow Cisco Learning & Certifications

X | Threads | Facebook | LinkedIn | Instagram | YouTube

Use  #CiscoU and #CiscoCert to join the conversation.

Adaptability: The Must-Have Skill for Network Engineers in the AI Era

MCP for DevOps, NetOps, and SecOps: Real-World Use Cases and Future Insights