# NetworkOps Platform

> AI-powered network automation via Netbox and Model Context Protocol (MCP). 178 tools for multi-vendor infrastructure management, self-healing agents, drift detection, and a real-time web dashboard.

- **Type:** MCP server
- **Install:** `agentstack add mcp-e-conners-lab-networkops-platform`
- **Verified:** Pending review
- **Seller:** [E-Conners-Lab](https://agentstack.voostack.com/s/e-conners-lab)
- **Installs:** 0
- **Category:** [Data & Analytics](https://agentstack.voostack.com/c/data-and-analytics)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [E-Conners-Lab](https://github.com/E-Conners-Lab)
- **Source:** https://github.com/E-Conners-Lab/NetworkOps_Platform

## Install

```sh
agentstack add mcp-e-conners-lab-networkops-platform
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# NetworkOps
[](https://github.com/E-Conners-Lab/NetworkOps_Platform/releases)
[](https://www.python.org/downloads/)
[](https://modelcontextprotocol.io/)

**AI-Powered Network Automation Platform**

> Natural language commands to manage multi-vendor infrastructure

NetworkOps is a network automation platform built on the Model Context Protocol (MCP). It enables AI-assisted management of Cisco, Juniper, Nokia, Arista, and Linux devices through natural language — no scripting required.

---

## Screenshots

### Topology Dashboard
Interactive force-directed network topology with device health indicators, legend, and network stats.

### Device Details
Click any device to view its properties, interface status, and remediation controls.

### OSPF Adjacencies Overlay
Visualize OSPF adjacencies with area labels directly on topology links.

### BGP Sessions Overlay
BGP session status with AS number annotations on peering links.

### DMVPN Fabric Status
DMVPN hub-and-spoke overlay with peer state table showing tunnel IPs, NBMA addresses, and uptime.

### Ping Sweep with Latency Heatmap
Bulk ping results visualized as a color-coded latency heatmap across the topology.

### Command Terminal
Execute show commands on any device with full output display.

### AI Documentation Assistant
RAG-powered chat with live network queries — ask questions in natural language and get answers with source citations.

### Real-time Telemetry (MDT)
Live CPU, memory, interface traffic, and counters streamed via gRPC at 5-second intervals.

### Impact Analysis
Predict the blast radius of a configuration change before executing it.

### Intent Drift Engine
YAML-defined expected state validation with per-item compliance checks and violation alerts.

### Subnet Calculator
Built-in subnet calculator with VLSM split and quick reference tables.

---

## Quick Start

### Demo Mode (no network devices needed)

Try NetworkOps without any hardware. Demo mode simulates a multi-device network with routers, switches, and an FRR edge device.

```bash
git clone https://github.com/E-Conners-Lab/NetworkOps_Platform.git && cd NetworkOps_Platform
./scripts/quickstart.sh --demo
# Follow the prompts, then open http://localhost:5001 — Login: admin/admin
```

Or manually:

```bash
git clone https://github.com/E-Conners-Lab/NetworkOps_Platform.git && cd NetworkOps_Platform
uv venv --python 3.11                  # downloads Python 3.11 if needed
source .venv/bin/activate
uv pip install -r requirements.txt
cd dashboard && npm install && npm run build && cd ..
JWT_SECRET=$(python3 -c "import secrets; print(secrets.token_hex(32))")
DEMO_MODE=true JWT_SECRET=$JWT_SECRET python dashboard/api_server.py
```

> **Don't have uv?** Install it with `curl -LsSf https://astral.sh/uv/install.sh | sh`. You can also use `python3.11 -m venv .venv` and `pip install -r requirements.txt` instead.

### With Real Devices

```bash
git clone https://github.com/E-Conners-Lab/NetworkOps_Platform.git && cd NetworkOps_Platform
./scripts/quickstart.sh
# Edit .env with your device IPs and credentials
# Edit config/devices.py with your device inventory
python dashboard/api_server.py
```

### Docker

```bash
git clone https://github.com/E-Conners-Lab/NetworkOps_Platform.git && cd NetworkOps_Platform
./scripts/docker-init.sh
# Edit .env with your credentials (or add DEMO_MODE=true for demo)
docker compose up
```

---

## Demo Mode

Demo mode provides a fully functional dashboard experience using simulated network data. No real devices, SSH connections, or lab infrastructure required.

### What Works in Demo Mode

| Feature | Status | Details |
|---------|--------|---------|
| **Topology visualization** | Full | 7-node network with routers, switches, and FRR edge device |
| **BGP overlay** | Full | Simulated iBGP (AS 65000) and eBGP (AS 65100) peering |
| **OSPF overlay** | Full | Area 0 adjacencies across all routers |
| **DMVPN overlay** | Full | Hub-and-spoke topology with 3 spokes |
| **Switch fabric overlay** | Full | 2 switches with uplink status and port counts |
| **Ping sweep** | Full | Simulated 100% reachability with realistic latencies |
| **Interface list** | Full | Per-device interface display with status |
| **Show commands** | Partial | `show ip interface brief`, `show version`, `show ip route` return simulated output; other commands return a placeholder message |
| **Login / RBAC** | Full | JWT auth, role-based permissions, all dashboard features unlocked |
| **Health endpoints** | Full | `/healthz` and `/health/detailed` work without Redis |

### What Does Not Work in Demo Mode

| Feature | Reason |
|---------|--------|
| **Configuration changes** | No real devices to push config to |
| **NETCONF/YANG queries** | Requires live device connections |
| **pyATS baselines/diffs** | Requires SSH to real devices |
| **RAG chatbot** | Requires `ANTHROPIC_API_KEY` and ChromaDB index |
| **Streaming telemetry** | Requires gRPC streams from real devices |
| **Terminal (arbitrary commands)** | Most commands return placeholder output |
| **NetBox integration** | Requires a running NetBox instance |
| **MCP tools via Claude** | Tools that SSH to devices will fail; read-only tools work |

### Demo Topology

```
        R1 ──── R2
        │        │
   Switch-R1  Switch-R2
        │
        R3 ──── R4
        │
      edge1 (FRR, AS 65100)
```

- **R1–R4**: Cisco C8000V routers (IOS-XE) — OSPF Area 0, iBGP AS 65000, DMVPN hub/spoke
- **Switch-R1, Switch-R2**: Cisco Cat9kv switches
- **edge1**: FRRouting device — eBGP peering with R3

---

## Features

### React Dashboard
- Interactive force-directed topology with drag-and-drop positioning
- Real-time device health monitoring (healthy / degraded / critical)
- Role-based access control (Admin / Operator / Viewer)
- Command terminal with output display
- AI chat panel (RAG-powered, requires Anthropic API key)
- Device detail panels:
  - Cisco devices: Interface list with admin/line protocol status, remediation buttons
  - Linux hosts: Uptime, memory, disk, gateway reachability
  - Containerlab devices: Container status, uptime, memory
- Visualization overlays:
  - BGP session status with AS numbers
  - OSPF adjacencies with area mapping
  - DMVPN hub/spoke fabric
  - Switch fabric with EIGRP status
  - Ping sweep with latency heatmap
- Intent Drift Engine:
  - YAML-defined expected state validation
  - Force-directed dependency graph
  - Forward/backward/blast-radius impact analysis
  - Cross-subsystem event correlation
- Hierarchical site view (Region → Site → Rack → Device)
- Position persistence via localStorage
- Change management workflow

### MCP Tools (178 tools, 24 categories)

Integrate with Claude Code or Claude Desktop for natural language network management.

#### Health & Monitoring
| Tool | Description |
|------|-------------|
| `health_check` | Check single device connectivity |
| `health_check_all` | Parallel health check across all devices |
| `full_network_test` | Validate OSPF, BGP, DMVPN, and reachability |
| `linux_health_check` | Linux host status (uptime, memory, disk) |
| `get_cpu_memory` | CPU and memory utilization |
| `ping_sweep` | Bulk ping from a device to all targets |

#### Device Operations
| Tool | Description |
|------|-------------|
| `get_devices` | List available devices |
| `send_command` | Execute show commands |
| `send_config` | Send configuration commands |
| `discover_topology` | Discover topology via CDP/LLDP |
| `get_interface_status` | Detailed interface status |
| `remediate_interface` | Fix interfaces (no shutdown, bounce) |
| `bulk_command` | Execute command on multiple devices in parallel |

#### Configuration Management
| Tool | Description |
|------|-------------|
| `backup_config` | Save running config to timestamped file |
| `compare_configs` | Diff two configs or backup files |
| `list_backups` | List saved configuration backups |

#### Routing & Troubleshooting
| Tool | Description |
|------|-------------|
| `get_routing_table` | Parsed routing table with protocol filtering |
| `traceroute` | Hop-by-hop path analysis |
| `get_arp_table` | Parsed ARP table with VRF support |
| `get_mac_table` | MAC address table from switches |
| `get_neighbors` | Structured CDP/LLDP neighbor data |
| `get_logs` | Syslog buffer with severity filtering |

#### NETCONF
| Tool | Description |
|------|-------------|
| `get_interfaces_netconf` | Interface info via NETCONF/YANG |
| `get_netconf_capabilities` | Device NETCONF capabilities |
| `get_bgp_neighbors_netconf` | BGP neighbors via NETCONF |

#### pyATS Integration
| Tool | Description |
|------|-------------|
| `pyats_learn_feature` | Learn device feature state |
| `pyats_snapshot_state` | Capture device state baseline |
| `pyats_diff_state` | Compare against baseline |
| `pyats_check_compliance` | Check config against golden templates |
| `pyats_list_baselines` | List saved baselines |
| `pyats_list_templates` | List golden config templates |

#### NetBox Integration
| Tool | Description |
|------|-------------|
| `netbox_get_devices` | List devices from NetBox |
| `netbox_get_interfaces` | Device interfaces from NetBox |
| `netbox_get_prefixes` | IP prefixes from NetBox |
| `netbox_generate_configs` | Generate FRR configs from NetBox via Jinja2 |
| `netbox_generate_iosxe_config` | Generate IOS-XE configs from NetBox |
| `netbox_allocate_ip` | Allocate next available IP from a prefix |

#### Memory & Context System
| Tool | Description |
|------|-------------|
| `memory_search` | Semantic search across conversation history |
| `memory_save` | Save notes for later retrieval |
| `memory_recall_device` | Recent events for a device |
| `memory_stats` | Memory system statistics |

#### Event Logging & Cache
| Tool | Description |
|------|-------------|
| `get_event_log` | Audit log events (filterable) |
| `clear_event_log` | Clear audit log |
| `cache_status` | Redis cache statistics |

### Streaming Telemetry (MDT)
- Real-time CPU, memory, and interface counters via gRPC (5-second intervals)
- WebSocket push to dashboard via Socket.IO
- Configured on C8000V routers and Cat9kv switches

### RAG Documentation Chatbot
- Indexed CCIE/Cisco documentation with semantic search
- ChromaDB + sentence-transformers embeddings
- Live network queries via SSH during chat
- Claude-powered responses with source citations

### Discord Bot (ChatOps)
- Commands: `!devices`, `!health`, `!bgp`, `!ping`, `!events`, `!topology`, `!run`
- RBAC: Admin commands require "Network Admin" role

### Enterprise Features

| Category | Feature |
|----------|---------|
| **Authentication** | JWT tokens, MFA/TOTP with recovery codes |
| **Authorization** | Role-based access control (Admin/Operator/Viewer) |
| **Caching** | Redis-backed response caching |
| **Rate Limiting** | Configurable per-endpoint rate limits |
| **Async Jobs** | Celery task queue with PostgreSQL persistence |
| **Health Probes** | `/healthz`, `/readyz`, `/health/detailed`, `/metrics` |
| **TLS/HTTPS** | Nginx reverse proxy with TLS 1.2/1.3 |
| **Logging** | Structured JSON logs for aggregation |
| **SIEM Forwarding** | Splunk, Elasticsearch, Syslog, Webhook |
| **Kubernetes** | Full manifests with HPA, PDB, rolling deployments |
| **Graceful Shutdown** | SIGTERM handling with request draining |

---

## Architecture

```
┌─────────────────────────────────────────────────────────────────────┐
│                        NetworkOps Platform                          │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   ┌──────────────┐    ┌──────────────┐    ┌────────────────────┐   │
│   │   Frontend   │    │  API Server  │    │    MCP Server      │   │
│   │   (React)    │◄──►│   (Flask)    │    │  (Claude Tools)    │   │
│   │  Port 3000   │    │  Port 5001   │    │                    │   │
│   │              │    │              │    │  178 tools across  │   │
│   │  • Topology  │    │  • REST API  │    │  24 categories     │   │
│   │  • Terminal  │    │  • WebSocket │    │  • NETCONF/YANG    │   │
│   │  • RAG Chat  │    │  • Auth/RBAC │    │  • pyATS           │   │
│   └──────────────┘    └──────┬───────┘    └──────────┬─────────┘   │
│                              │                       │              │
│                 ┌────────────┴───────────────────────┴──────────┐  │
│                 │             Shared Data Layer                  │  │
│                 │  • networkops.db (Alembic-managed)             │  │
│                 │  • chromadb/ (RAG)    • baselines/ (pyATS)     │  │
│                 └───────────────────────┬───────────────────────┘  │
│                                         │                          │
├─────────────────────────────────────────┼──────────────────────────┤
│                                         │                          │
│              Network Devices (SSH / NETCONF)                       │
│   ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌───────┐ │
│   │ Cisco   │  │ Juniper │  │ Nokia   │  │ Arista  │  │ Linux │ │
│   │ IOS-XE  │  │ Junos   │  │ SR Linux│  │  EOS    │  │ FRR   │ │
│   └─────────┘  └─────────┘  └─────────┘  └─────────┘  └───────┘ │
└─────────────────────────────────────────────────────────────────────┘
```

---

## Setting Up Your Own Lab

Use the quickstart script to configure NetworkOps for your own network devices:

```bash
# Interactive setup (recommended)
./scripts/quickstart.sh

# Demo mode (no devices needed)
./scripts/quickstart.sh --demo

# Non-interactive (CI/CD, Docker)
./scripts/quickstart.sh --headless

# Setup and auto-start
./scripts/quickstart.sh --headless --auto-start
```

The script detects [uv](https://docs.astral.sh/uv/) automatically for faster dependency installation.

### Deploying on a Linux VM (Proxmox, bare metal, etc.)

You can run the entire platform and containerlab on a single Linux host — no Multipass needed.

**1. Install prerequisites:**

```bash
# Docker
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER && newgrp docker

# Containerlab
sudo bash -c "$(curl -sL https://get.containerlab.dev)"

# uv (Python version manager + package installer)
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc

# Node.js (for building the React frontend)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
```

**2. Clone and set up the project:**

```bash
git clone https://github.com/E-Conners-Lab/NetworkOps_Platform.git && cd NetworkOps_Platform
uv venv --python 3.11
source .venv/bin/activate
uv pip install -r requirements.txt
```

**3. Configure `.env`:**

```bash
cp .env.example .env
```

Set these values in `.env`:

```bash
CONTAINERLAB_LOCAL=true
CONTAINERLAB_ONLY=true
CONTAINERLAB_TOPOLOGY_PATH=/path/to/NetworkOps_Platform/containerlab/datacenter.clab.yml
DEMO_MODE=false
JWT_SECRET=
```

**4. Pull images and deploy the lab:**

```bash
docker pull frrouting/frr:v8.4.1
docker pull ghcr.io/nokia/srlinux:24.10.1
docker pull alpine:3.19

cd containerlab
sudo containerlab deploy -t datacenter.clab.yml
cd ..
```

**5. Build the frontend, run migrations, and start:**

```bash
cd dashboard && npm install && npm run build && cd ..
alembic upgrade head
python dashboard/api_server.py
```

**6. Change the default password:**

```bash
TOKEN=$(curl -s http://localhost:5001/api/auth/login -H "Content-Type: application/json" -d '{"username":"admin","password":"admin"}' | python3 -c "import sys,json;print(json.load(sys.stdin)['token'])")

curl -X POST http://localhost:5001/api/auth/change-password -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" -d '{"old_password":"admin","new_password":"YourNewPassword"}'
```

**7. Access the dashboard** at `http://:5001` and log in with `admin` and your new password.

> **Note:** `CONTAINERLAB_LOCAL=true` runs Docker commands directly instead of routing through Multipass. `CONTAINERLAB_ONLY=true` hides EVE-NG/phys

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [E-Conners-Lab](https://github.com/E-Conners-Lab)
- **Source:** [E-Conners-Lab/NetworkOps_Platform](https://github.com/E-Conners-Lab/NetworkOps_Platform)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-e-conners-lab-networkops-platform
- Seller: https://agentstack.voostack.com/s/e-conners-lab
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.