Which integrations are available for this server?

Provides tools for querying Cisco network devices (IOS-XR, NX-OS, IOS) including BGP, OSPF, MPLS, interfaces, alarms, and more via SSH, NETCONF, and SNMP. Provides tools for querying Nokia SR OS network devices including BGP, OSPF, MPLS, interfaces, services (VPRN, VPLS, SAP), and more via SSH, NETCONF, and SNMP.

How do I use MCP-Telecom?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP-Telecom Show BGP summary on nokia-pe1 and check for down peers" 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.

MCP-Telecom

by Avinash-Amudala

Overview Schema Related Servers Score Discussions

Python

Hybrid

MCP-Telecom

Let AI agents talk to your network equipment.

The first MCP server for Nokia SR OS, Cisco IOS-XR, Juniper Junos, Arista EOS, and Cisco NX-OS routers.

"Hey Claude, show me the BGP summary on nokia-pe1 and check if any peers are down."

MCP-Telecom bridges the gap between AI assistants and network infrastructure. It implements the Model Context Protocol (MCP) to give AI agents like Claude and GPT secure, read-only access to your network devices via SSH — no custom scripts, no fragile automation, just natural language.

Why MCP-Telecom?

Problem	Solution
Network engineers SSH into devices one-by-one	AI queries multiple devices in parallel
Vendor CLI syntax differs across Nokia, Cisco, Juniper	Unified interface — one tool works across all vendors
Junior engineers struggle with complex troubleshooting	AI-guided workflows with built-in troubleshooting prompts
No audit trail for ad-hoc show commands	Every command logged with timestamps
Automation scripts break across vendor upgrades	Vendor-abstracted command mappings maintained in one place

Related MCP server: Junos MCP Server

Features

Multi-Vendor Support — Nokia SR OS, Cisco IOS / IOS-XR / NX-OS, Juniper Junos, Arista EOS
60+ Network Tools — BGP, OSPF, MPLS, interfaces, alarms, NTP, ARP, MAC tables, and more
Vendor Abstraction — Say bgp_summary and get the right command for any vendor
NETCONF/YANG — Structured data retrieval via NETCONF alongside traditional SSH CLI
Streaming Telemetry — gNMI-based telemetry subscriptions with in-memory cache
SNMP MIB Polling — Query SNMP OIDs, walk MIB subtrees, device overviews via SNMPv2c/v3
Topology Discovery — Auto-build network maps from LLDP/CDP data with path finding
Multi-Device Parallel Queries — Run commands across all devices simultaneously via thread pool
Config Compliance — Check configs against 20+ security best-practice rules with scoring
Connection Pooling — Persistent SSH sessions with idle timeout and automatic cleanup
Web Dashboard — Real-time device status dashboard with auto-refresh (FastAPI)
Prometheus Metrics — Export device health and command metrics for Grafana dashboards
Containerlab Integration — Generate lab topologies for testing without production access
Safety First — Only read-only commands allowed; destructive commands are blocked
Audit Logging — Every command execution recorded in structured JSONL format
Config Backup & Diff — Backup running configs and compare against previous versions
Health Checks — Test device reachability with response time measurement
MCP Resources — Device inventory, topology, telemetry, and compliance as browseable resources
Troubleshooting Prompts — Built-in BGP, interface, and health audit workflows
Nokia Service Tools — VPRN, VPLS, and SAP inspection for Nokia SR OS
PyPI Ready — pip install mcp-telecom with optional extras
Docker Support — Run containerized with docker-compose
CI/CD — GitHub Actions with multi-Python-version testing and PyPI publishing

Architecture

┌──────────────────────────────────────────────────────────────┐
│                     AI Agent (Claude/GPT)                    │
│                                                              │
│  "Check compliance on all routers"                           │
│  "Run BGP summary across all devices in parallel"            │
│  "Generate a containerlab topology for testing"              │
└──────────────────────┬───────────────────────────────────────┘
                       │  MCP Protocol (stdio)
                       ▼
┌──────────────────────────────────────────────────────────────┐
│                  MCP-Telecom Server v0.2.0                   │
│                                                              │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────────────┐  │
│  │ 60+ Tools│ │Resources │ │ Prompts  │ │ Safety/Audit   │  │
│  └────┬─────┘ └──────────┘ └──────────┘ └────────────────┘  │
│       │                                                      │
│  ┌────▼──────────────────────────────────────────────────┐   │
│  │            Vendor Command Mappings (35+ ops)          │   │
│  │   Nokia ── Cisco ── Juniper ── Arista ── NX-OS        │   │
│  └────┬──────────┬──────────┬──────────┬─────────────────┘   │
│       │          │          │          │                      │
│  ┌────▼────┐ ┌───▼────┐ ┌──▼──────┐ ┌─▼───────┐             │
│  │  SSH    │ │NETCONF │ │Telemetry│ │  SNMP   │             │
│  │(Netmiko)│ │(YANG)  │ │ (gNMI)  │ │(pysnmp) │             │
│  └────┬────┘ └───┬────┘ └──┬──────┘ └─┬───────┘             │
│       │          │         │          │                      │
│  ┌────▼──────────▼─────────▼──────────▼───────────────────┐  │
│  │  Connection Pool │ Parallel Executor │ Compliance      │  │
│  │  Topology │ Dashboard │ Prometheus │ Containerlab      │  │
│  └────────────────────────────────────────────────────────┘  │
└──────────────┬──────────────┬──────────────┬─────────────────┘
               │              │              │
               ▼              ▼              ▼
     ┌──────────────┐ ┌──────────┐ ┌──────────────┐
     │ Nokia SR OS  │ │ Cisco XR │ │ Juniper/EOS  │
     └──────────────┘ └──────────┘ └──────────────┘

Quick Start

Prerequisites

Python 3.10+
uv package manager
SSH access to your network devices

Installation

# Install from PyPI
pip install mcp-telecom

# With optional extras
pip install mcp-telecom[netconf]     # NETCONF/YANG support
pip install mcp-telecom[telemetry]   # gNMI streaming telemetry
pip install mcp-telecom[snmp]        # SNMP MIB polling
pip install mcp-telecom[dashboard]   # Web dashboard (FastAPI)
pip install mcp-telecom[metrics]     # Prometheus metrics exporter
pip install mcp-telecom[all]         # Everything

# Or from source
git clone https://github.com/Avinash-Amudala/MCP-Telecom.git
cd MCP-Telecom
uv sync       # or: pip install -e .

Configure Your Devices

# Copy the example config and edit with your device details
cp devices.yaml.example devices.yaml

Edit devices.yaml with your actual device credentials:

nokia-pe1:
  device_type: nokia_sros
  host: 192.168.1.1
  username: your_username
  password: "${NOKIA_PASSWORD}"   # replace with real creds
  port: 22

cisco-xr1:
  device_type: cisco_xr
  host: 192.168.2.1
  username: your_username
  password: "${CISCO_PASSWORD}"

juniper-mx1:
  device_type: juniper_junos
  host: 192.168.3.1
  username: your_username
  password: "${JUNIPER_PASSWORD}"

Test with MCP Inspector

npx @modelcontextprotocol/inspector uv run mcp-telecom

Use with Claude Desktop

Add to your Claude Desktop config (claude_desktop_config.json):

{
  "mcpServers": {
    "mcp-telecom": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "/path/to/MCP-Telecom",
        "mcp-telecom"
      ],
      "env": {
        "MCP_TELECOM_DEVICES_FILE": "/path/to/MCP-Telecom/devices.yaml"
      }
    }
  }
}

Once configured, the server appears in Claude Desktop under Settings → Developer:

Available Tools

Routing & Protocols

Tool	Description
`show_bgp_summary`	BGP neighbor summary with peer states
`show_bgp_neighbors`	Detailed BGP neighbor information
`show_routing_table`	Full IP routing table
`show_ospf_neighbors`	OSPF neighbor adjacencies
`show_mpls_lsp`	MPLS Label Switched Paths

Interfaces & Layer 2

Tool	Description
`show_interfaces`	Interface status summary
`show_interface_detail`	Detailed per-interface statistics
`show_lldp_neighbors`	LLDP neighbor discovery
`show_lag_status`	LAG/Port-Channel/Bundle status
`show_arp_table`	IP-to-MAC ARP cache
`show_mac_table`	MAC address table

System Monitoring

Tool	Description
`show_system_info`	Version, uptime, hardware
`show_alarms`	Active alarms and alerts
`show_ntp_status`	NTP synchronization state
`show_cpu`	CPU utilization
`show_memory`	Memory utilization
`show_environment`	Power, fans, temperature
`show_log_events`	Recent syslog messages

Configuration & Operations

Tool	Description
`backup_config`	Backup running config with timestamp
`compare_configs`	Diff live config against a backup
`run_command`	Execute any safe read-only command
`run_vendor_operation`	Run named operation with auto vendor translation
`list_devices`	List all configured devices
`list_device_capabilities`	Show supported operations per device
`health_check`	Test device reachability
`get_audit_log`	View command execution history
`show_nokia_services`	Nokia VPRN/VPLS/SAP services

NETCONF / YANG

Tool	Description
`netconf_get_config`	Retrieve config via NETCONF (structured XML)
`netconf_get_operational`	Get operational state via YANG models
`netconf_capabilities`	List device YANG module support

Streaming Telemetry (gNMI)

Tool	Description
`telemetry_subscribe`	Start gNMI telemetry subscription
`telemetry_query`	Query latest collected telemetry data
`telemetry_history`	Get time-series telemetry for trend analysis
`telemetry_list_subscriptions`	List active telemetry subscriptions
`telemetry_unsubscribe`	Stop a telemetry subscription
`telemetry_list_paths`	Show available OpenConfig telemetry paths

Topology Discovery

Tool	Description
`discover_topology`	Build network map from LLDP/CDP data
`show_topology`	Display ASCII network diagram
`show_topology_json`	Export topology as JSON
`show_topology_mermaid`	Export topology as Mermaid diagram
`find_path`	Shortest path between two devices (BFS)
`show_device_neighbors`	List discovered neighbors for a device

SNMP MIB Polling

Tool	Description
`snmp_get`	Poll specific SNMP OIDs from a device
`snmp_walk`	Walk an SNMP MIB subtree (e.g., IF-MIB)
`snmp_device_overview`	Quick SNMP-based device summary

Multi-Device Parallel Queries

Tool	Description
`parallel_command`	Run a CLI command on all devices simultaneously
`parallel_operation`	Run a vendor-mapped operation across all devices
`compare_devices`	Compare output across devices to find drift
`parallel_health_check`	Health-check all devices in parallel

Config Compliance

Tool	Description
`compliance_check`	Score a device against 20+ security rules
`compliance_check_rule`	Check a specific compliance rule
`compliance_list_rules`	List all available compliance rules

Containerlab Integration

Tool	Description
`clab_generate`	Generate a containerlab topology for lab testing
`clab_devices_yaml`	Generate devices.yaml for a lab deployment
`clab_scenarios`	List available pre-built lab scenarios

Dashboard & Metrics

Tool	Description
`start_dashboard`	Instructions to launch the web status dashboard
`start_metrics_endpoint`	Instructions to start Prometheus metrics exporter
`pool_stats`	Show SSH connection pool statistics

How Companies Use MCP-Telecom

MCP-Telecom is designed for zero-friction deployment inside enterprise networks:

Setup for Teams (5 minutes)

Install: pip install mcp-telecom on any machine with SSH access to network devices
Configure: Copy devices.yaml.example → devices.yaml and fill in device IPs + credentials
Run: Add the MCP server to Claude Desktop config (one JSON block)
Done: Engineers can now query any device through natural language

Security Model

Credentials stay local — devices.yaml lives on the engineer's machine, never leaves the network
Read-only by default — Only show/display commands allowed; configure/delete/shutdown blocked
Full audit trail — Every command logged with timestamp, device, user, success/failure
No cloud dependency — MCP runs over local stdio; no data leaves your infrastructure
Compliance built-in — Run compliance_check to validate configs against security baselines

Enterprise Deployment Options

Method	Best For
Local install	Individual engineers, quick evaluation
Docker	Shared team server, consistent environment
Containerlab	Lab testing before production rollout
Prometheus + Grafana	NOC dashboards, continuous monitoring

Is It Hard to Set Up?

No. The entire setup is: install the package, edit one YAML file with your device IPs and credentials, and add one config block to Claude Desktop. There is no cloud account, no API key from us, no SaaS subscription. Everything runs locally inside your network perimeter.

For teams, a network admin creates one devices.yaml and shares it internally. Each engineer points their Claude Desktop config to the shared MCP server or runs their own local instance.

Supported Platforms

Vendor	Device Types	Netmiko Type
Nokia	7750 SR, 7950 XRS, 7250 IXR	`nokia_sros`
Cisco	IOS, IOS-XE	`cisco_ios`
Cisco	IOS-XR (NCS, ASR)	`cisco_xr`
Cisco	NX-OS (Nexus)	`cisco_nxos`
Juniper	MX, QFX, EX, SRX	`juniper_junos`
Arista	7000, 7500 series	`arista_eos`

Safety & Security

MCP-Telecom enforces strict read-only access:

Allowed: show, display, ping, traceroute commands
Blocked: configure, set, delete, commit, reload, shutdown, write, clear, reset, debug, and 20+ other dangerous patterns
Audit Trail: Every command execution is logged with timestamp, device, success/failure, and output length

[2026-04-06T12:00:00Z] OK   nokia-pe1       show router bgp summary
[2026-04-06T12:00:05Z] OK   cisco-xr1       show ip interface brief
[2026-04-06T12:00:10Z] FAIL cisco-xr1       configure terminal  ← BLOCKED

Docker

# Build and run
docker-compose up -d

# Or build manually
docker build -t mcp-telecom .
docker run -v ./devices.yaml:/app/devices.yaml:ro mcp-telecom

Development

# Install dev dependencies
uv sync --all-extras

# Run tests
uv run pytest tests/ -v

# Lint
uv run ruff check src/ tests/

# Test with MCP Inspector
npx @modelcontextprotocol/inspector uv run mcp-telecom

Project Structure

MCP-Telecom/
├── src/mcp_telecom/
│   ├── __init__.py          # Package init
│   ├── server.py            # MCP server (60+ tools, resources, prompts)
│   ├── connection.py        # SSH connection manager (Netmiko)
│   ├── models.py            # Pydantic data models
│   ├── safety.py            # Command safety validation
│   ├── audit.py             # Structured JSONL audit logging
│   ├── topology.py          # LLDP/CDP topology discovery & path finding
│   ├── pool.py              # Connection pooling (persistent SSH sessions)
│   ├── parallel.py          # Multi-device parallel query executor
│   ├── compliance.py        # Config compliance checker (20+ rules)
│   ├── dashboard.py         # Real-time web dashboard (FastAPI)
│   ├── metrics.py           # Prometheus metrics exporter
│   ├── containerlab.py      # Containerlab topology generator
│   ├── vendors/
│   │   ├── __init__.py
│   │   └── mappings.py      # Vendor-specific command mappings (6 vendors)
│   ├── transports/
│   │   ├── __init__.py
│   │   ├── netconf.py       # NETCONF/YANG transport (ncclient)
│   │   ├── telemetry.py     # gNMI streaming telemetry collector
│   │   └── snmp.py          # SNMP MIB polling (pysnmp)
│   └── tools/
│       ├── __init__.py
│       ├── routing.py       # Routing protocol tools
│       ├── interfaces.py    # Interface monitoring tools
│       └── system.py        # System monitoring tools
├── tests/                   # 157 tests
├── assets/                  # Demo GIF, screenshots
├── .github/workflows/
│   ├── ci.yml               # CI pipeline (Python 3.10-3.12 + Docker)
│   └── publish.yml          # PyPI publish on GitHub release
├── pyproject.toml           # Project config with optional extras
├── Dockerfile               # Container support
├── docker-compose.yml       # Docker Compose config
├── devices.yaml.example     # Example device config
└── README.md                # This file

Roadmap

NETCONF/YANG — Structured data retrieval via NETCONF
Streaming telemetry — gNMI-based real-time telemetry collection
Topology discovery — Auto-build network maps from LLDP/CDP
PyPI publishing — pip install mcp-telecom
SNMP MIB polling — SNMPv2c/v3 OID queries and MIB walks
Connection pooling — Persistent SSH sessions with idle timeout
Config compliance — 20+ rules, scoring, remediation advice
Multi-device parallel queries — Thread pool across all devices
Web dashboard — FastAPI real-time device status dashboard
Prometheus metrics — Export to Grafana with 8 metric types
Containerlab integration — Generate lab topologies for testing
MCP Registry listing — Publish to the official MCP Registry
Remote MCP server — HTTP/SSE transport for Claude's MCP Directory

Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

License

MIT — Avinash Amudala

Built with MCP + Netmiko + FastMCP

Install Server

license - permissive license

quality

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

0dRelease cycle

3Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Tools

View all tools

Latest Blog Posts

Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
open source
OpenAI
Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Avinash-Amudala/MCP-Telecom'

If you have feedback or need assistance with the MCP directory API, please join our Discord server