Skip to main content
Glama
Network MCP Server
by labeveryday

Network MCP Server

A Model Context Protocol (MCP) server providing network diagnostic tools for AI agents. Designed to offload heavy network analysis to the server and return structured, actionable data optimized for LLM consumption.

PyPI version Python 3.10+ License: MIT

Features

  • Connectivity Testing: ping, traceroute, DNS lookups, port checks, MTR

  • Batch Operations: Test multiple hosts/ports concurrently

  • Local Network Info: Get interfaces, routes, DNS config, ARP table, connections (cross-platform)

  • Pcap Analysis: Analyze packet captures with scapy (no tshark required)

  • Custom Filters: Execute scapy filter expressions for advanced queries (AST-validated)

  • Security Controls: Configurable allowlist/blocklist for target validation (enforced on connectivity tools)

  • PCAP Path Guardrails: Restrict which directories the server is allowed to read captures from

  • Smart Summaries: Returns human-readable summaries plus structured data

Related MCP server: WireMCP

Installation

pip install network-mcp

Or install from source:

git clone https://github.com/labeveryday/network-mcp.git
cd network-mcp
pip install -e .

Quick Start

Run the MCP server:

network-mcp

Or with Python:

python -m network_mcp.server

Recommended first run (helps agents decide what’s safe/available on this host):

  • Check capabilities: call capabilities to see installed binaries (like mtr), active security policy, and PCAP path guardrails.

  • Decide on policy: if you need to loosen/tighten target validation or PCAP access, set env vars before launching.

  • Run unit tests by default: pytest skips integration tests unless you opt in (see Development).

Available Tools

Diagnostics

Tool

Description

capabilities

Report runtime capabilities (installed binaries like mtr, active security policy, pcap path guardrails) so agents can plan tool usage

Planning (Pure CIDR/VLAN math)

Designed for Tier 1 / Tier 2 NOC workflows. These tools are pure (no network calls, deterministic outputs) and safe to use for planning and validation.

Tool

Description

cidr_info

CIDR primitives (IPv4/IPv6): network, usable range, mask/wildcard, counts

ip_in_subnet

Check whether an IP is in a subnet and whether it’s a usable host address

subnet_split

Split a CIDR into equal-size child subnets (by new prefix or power-of-two count)

cidr_summarize

Collapse/aggregate CIDRs into summarized routes (IPv4/IPv6 handled separately)

check_overlaps

Find overlaps/containment conflicts between CIDRs

validate_vlan_map

Validate a 1-subnet-per-VLAN map and surface overlaps

find_vlan_for_ip

Find which VLAN matches an IP from a provided VLAN map (Tier 1 “where does this belong?”)

ip_in_vlan

Check if an IP belongs to a VLAN; if not, provide a best-guess VLAN match (when unique)

plan_subnets

Allocate VLAN subnets from a parent IPv4 block (deterministic)

Input examples

  • VLAN map (both formats accepted):

{
  "10": "192.168.10.0/24",
  "20": { "cidr": "192.168.20.0/24", "name": "Voice" }
}
  • plan_subnets requirements (aliases supported: hosts and prefix):

[
  { "vlan_id": 10, "name": "Users", "hosts": 120 },
  { "vlan_id": 20, "name": "Voice", "hosts": 60 },
  { "vlan_id": 30, "name": "Printers", "prefix": 26 }
]

External Intel

Tool

Description

rdap_lookup

WHOIS-style lookup using RDAP for domains and IPs

asn_lookup

Origin ASN lookup for an IP (BGP origin intel)

Connectivity Tools

Tool

Description

ping

ICMP ping with latency statistics and packet loss

traceroute

Path analysis showing each hop with latency

dns_lookup

DNS resolution (A, AAAA, MX, TXT, etc.) and reverse lookups

port_check

TCP port connectivity test with banner grabbing

mtr

Combined traceroute + ping with per-hop statistics

Batch Operations

Tool

Description

batch_ping

Ping multiple hosts concurrently

batch_port_check

Check multiple ports on a single host

batch_dns_lookup

Resolve multiple hostnames in parallel

Local Network Info Tools

Cross-platform tools that work on Linux, macOS, and Windows.

Tool

Description

get_interfaces

List network interfaces with IPs, MACs, and status

get_routes

Get routing table with default gateway

get_dns_config

Get configured DNS servers and search domains

get_arp_table

Get ARP cache (IP to MAC mappings)

get_connections

List active TCP/UDP connections

get_public_ip

Get public/external IP address as seen from the internet

Pcap Analysis Tools

Tool

Description

pcap_summary

High-level capture stats: packets, duration, protocols, top talkers

get_conversations

Network flows/conversations between endpoints

analyze_throughput

Observed throughput (Mbps) per conversation/flow, including dominant direction and duration

find_tcp_issues

Detect retransmissions, resets, zero windows, dup ACKs

analyze_dns_traffic

DNS queries, failures, slow responses

filter_packets

Extract packets by IP, port, or protocol

get_protocol_hierarchy

Protocol breakdown by packets and bytes

custom_scapy_filter

Execute custom scapy filter expressions

IDE Integration

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "network-tools": {
      "command": ["network-mcp"]
    }
  }
}

Cursor

Add to your MCP settings:

{
  "mcpServers": {
    "network-tools": {
      "command": ["network-mcp"]
    }
  }
}

Using with uv

If you installed with uv:

{
  "mcpServers": {
    "network-tools": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/network-mcp", "network-mcp"]
    }
  }
}

Example Responses

Ping

{
  "success": true,
  "target": "google.com",
  "resolved_ip": "142.250.80.46",
  "packets_sent": 4,
  "packets_received": 4,
  "packet_loss_percent": 0.0,
  "min_latency_ms": 11.2,
  "avg_latency_ms": 12.8,
  "max_latency_ms": 15.1,
  "summary": "google.com is reachable. 4/4 packets received, avg latency 12.8ms"
}

Batch Ping

{
  "success": true,
  "total_targets": 3,
  "successful": 3,
  "failed": 0,
  "results": [
    {"target": "8.8.8.8", "success": true, "avg_latency_ms": 12.5},
    {"target": "1.1.1.1", "success": true, "avg_latency_ms": 8.2},
    {"target": "google.com", "success": true, "avg_latency_ms": 15.1}
  ],
  "summary": "Batch ping: 3/3 targets reachable"
}

TCP Issues Detection

{
  "success": true,
  "file_path": "/tmp/capture.pcap",
  "total_tcp_packets": 15234,
  "issues": [
    {
      "issue_type": "retransmission",
      "count": 47,
      "severity": "medium",
      "recommendation": "Retransmissions indicate packet loss. Check for network congestion."
    }
  ],
  "has_issues": true,
  "summary": "TCP issues detected in 15234 packets: 47 retransmissions"
}

Throughput (from PCAP)

{
  "success": true,
  "file_path": "/tmp/capture.pcap",
  "total_packets_scanned": 100000,
  "conversations_analyzed": 87,
  "top_n": 3,
  "sort_by": "mbps_total",
  "conversations": [
    {
      "src_ip": "10.0.0.10",
      "src_port": 51544,
      "dst_ip": "93.184.216.34",
      "dst_port": 443,
      "protocol": "TCP",
      "packets_total": 1240,
      "bytes_total": 18423333,
      "duration_seconds": 9.84,
      "start_time": 1734567890.01,
      "end_time": 1734567899.85,
      "packets_forward": 820,
      "bytes_forward": 17600000,
      "packets_reverse": 420,
      "bytes_reverse": 823333,
      "mbps_forward": 14.308,
      "mbps_reverse": 0.669,
      "mbps_total": 14.977,
      "direction": "10.0.0.10:51544 -> 93.184.216.34:443"
    }
  ],
  "summary": "Throughput analysis: 87 conversations from 100000 packets. Top flow 10.0.0.10:51544 -> 93.184.216.34:443 at ~14.977 Mbps over 9.84s"
}

Get Interfaces

{
  "success": true,
  "interfaces": [
    {
      "name": "en0",
      "status": "up",
      "mac_address": "00:11:22:33:44:55",
      "ipv4_addresses": ["192.168.1.100"],
      "ipv6_addresses": ["fe80::1"],
      "netmask": "255.255.255.0",
      "mtu": 1500
    }
  ],
  "default_interface": "en0",
  "summary": "Found 5 interfaces (3 up). Primary: en0"
}

Get Public IP

{
  "success": true,
  "public_ip": "203.0.113.42",
  "service_used": "ipify.org",
  "summary": "Public IP: 203.0.113.42 (via ipify.org)"
}

RDAP Lookup (WHOIS-style)

{
  "success": true,
  "query": "1.1.1.1",
  "query_type": "ip",
  "rdap_url": "https://rdap.org/ip/1.1.1.1",
  "handle": "NET-1-1-1-0-1",
  "country": "AU",
  "start_address": "1.1.1.0",
  "end_address": "1.1.1.255",
  "summary": "RDAP 1.1.1.1: 1.1.1.0–1.1.1.255 (AU), handle NET-1-1-1-0-1"
}

ASN Lookup

{
  "success": true,
  "ip": "1.1.1.1",
  "asn": "13335",
  "prefix": "1.1.1.0/24",
  "country": "AU",
  "registry": "apnic",
  "allocated": "2011-08-11",
  "as_name": "CLOUDFLARENET",
  "summary": "1.1.1.1 originates from AS13335 (CLOUDFLARENET), prefix 1.1.1.0/24"
}

Configuration

Create config.yaml in your working directory or ~/.network-mcp/config.yaml:

security:
  # Only allow these targets (glob patterns, CIDR ranges)
  allowed_targets:
    - "*.company.com"
    - "10.0.0.0/8"
    - "192.168.0.0/16"

  # Block these targets
  blocked_targets:
    - "*.gov"
    - "localhost"
    - "127.0.0.0/8"

  # Block private IPs
  block_private: false

  # Block cloud metadata endpoints (AWS, GCP, etc.)
  block_cloud_metadata: true

pcap:
  max_packets: 100000
  allow_custom_filters: true
  # Restrict which directories the server is allowed to read pcaps from.
  # (Paths are resolved before checking.)
  allowed_paths:
    - "."
    - "~/Documents"
    - "/tmp"

Environment variables:

NETWORK_MCP_ALLOWED_TARGETS="*.company.com,10.0.0.0/8"
NETWORK_MCP_BLOCKED_TARGETS="*.gov,localhost"
NETWORK_MCP_BLOCK_PRIVATE="true"
NETWORK_MCP_MAX_PACKETS="50000"
NETWORK_MCP_PCAP_ALLOWED_PATHS=".,~/Documents,/tmp"

Why MCP for Network Tools?

Token Efficiency: LLMs have context limits. The server does heavy processing (parsing 100k packets) and returns concise summaries instead of raw data.

Better Reasoning: LLMs excel at deciding what to investigate, not parsing raw output. Structured data leads to better decisions.

Consistency: Server-side processing is deterministic. You don't rely on the LLM to correctly interpret traceroute output every time.

Examples

The examples/ directory contains working examples using Strands Agents:

Example

Description

ollama_agent.py

Interactive chat agent using Ollama (local models)

incident-demo/

Self-contained demo: AI diagnoses network outages with voice alerts

eval_agent.py

Evaluate how well models use the network tools

Quick start:

cd examples
pip install strands-agents strands-agents-tools 'strands-agents[ollama]'
python ollama_agent.py

See examples/README.md for full documentation.

Development

# Clone and install dev dependencies
git clone https://github.com/labeveryday/network-mcp.git
cd network-mcp
pip install -e ".[dev]"

# Run unit tests (integration tests are skipped by default)
pytest

# Run integration tests (requires system tools and/or network access)
pytest -m integration

# Run linting
ruff check .

Project Structure

network-mcp/
├── src/network_mcp/
│   ├── __init__.py
│   ├── server.py           # FastMCP server
│   ├── config.py           # Configuration and security
│   ├── tools/
│   │   ├── connectivity.py # ping, traceroute, dns, port_check, mtr, batch ops
│   │   ├── local.py        # local network info (interfaces, routes, etc.)
│   │   └── pcap.py         # pcap analysis tools
│   └── models/
│       └── responses.py    # Pydantic response models
├── tests/
├── pyproject.toml
└── README.md

Requirements

  • Python 3.10+

  • System tools: ping, traceroute (standard on most systems)

  • Optional: mtr for the MTR tool

License

MIT License - see LICENSE file for details.

Available Tools

34 tools
analyze_dns_trafficA

Analyze DNS queries and responses in a packet capture.

Use this tool to understand DNS activity including:

  • Most queried domains

  • Failed queries (NXDOMAIN, SERVFAIL)

  • Slow DNS responses (>100ms)

Args: file_path: Path to the pcap or pcapng file max_packets: Maximum packets to analyze (default: 100000)

Returns: DNS traffic analysis with top domains, failures, and slow queries

Inputs: file_path (required), max_packets.

analyze_throughputB

Calculate observed throughput per conversation (Mbps) from a pcap file.

This reports achieved throughput in the capture (not theoretical bandwidth).

Inputs: file_path (required), max_packets, top_n, sort_by.

asn_lookupB

Lookup origin ASN for an IP address (BGP origin intel).

Use this to quickly identify the ASN and prefix associated with an external IP.

Inputs: ip (required), timeout.

batch_dns_lookupA

Perform DNS lookups for multiple hostnames at once.

Use this tool when you need to resolve multiple hostnames or check DNS records for several domains efficiently.

Args: queries: List of hostnames to lookup record_type: DNS record type for all queries (default: A)

Returns: Batch results with per-query records, success/fail counts, and summary

Inputs: queries (required), record_type.

batch_pingA

Ping multiple hosts concurrently for efficient connectivity testing.

Use this tool when you need to check connectivity to multiple hosts at once. Results include per-target status and an overall summary. Targets are validated against the configured allowlist/blocklist.

Args: targets: List of hostnames or IP addresses to ping count: Number of ICMP packets per target (default: 4) timeout: Timeout in seconds per packet (default: 5) max_concurrent: Maximum concurrent pings (default: 10)

Returns: Batch results with per-target status, success/fail counts, and summary

Inputs: targets (required), count, timeout, max_concurrent.

batch_port_checkA

Check multiple TCP ports on a single host concurrently.

Use this tool to quickly scan multiple ports on a host, such as checking which common services are running. Returns open/closed status for each port.

Args: target: Hostname or IP address to check ports: List of TCP port numbers to check (e.g., [22, 80, 443, 3306]) timeout: Connection timeout per port in seconds (default: 2) max_concurrent: Maximum concurrent checks (default: 20)

Returns: Batch results with per-port status, open/closed counts, and summary

Inputs: target (required), ports (required), timeout, max_concurrent.

capabilitiesA

Report server/runtime capabilities and dependency status.

Use this tool first when running with local/smaller models so the agent can decide which tools will work (e.g., whether mtr is installed) and what security/pcap guardrails are active.

Inputs: no named parameters.

check_overlapsA

Detect overlaps/containment between CIDRs (high-leverage sanity check).

Inputs: cidrs (required).

cidr_infoA

CIDR primitives (IPv4/IPv6): mask, wildcard, usable range, counts.

NOC use cases:

  • Validate the mask math in a change ticket

  • Quickly answer "what's the usable range for this VLAN subnet?"

Inputs: cidr (required).

cidr_summarizeA

Summarize/aggregate routes from a list of CIDRs (IPv4/IPv6 collapsed separately).

Inputs: cidrs (required).

custom_scapy_filterA

Execute a custom scapy filter expression on a pcap file.

Use this tool for advanced packet filtering using scapy's syntax. The filter is validated for safety before execution.

Supported filter syntax examples:

  • "TCP in pkt and pkt[TCP].dport == 80" - HTTP traffic

  • "UDP in pkt and DNS in pkt" - DNS traffic

  • "pkt[IP].ttl < 64" - Packets with low TTL

  • "len(pkt) > 1000" - Large packets

Args: file_path: Path to the pcap or pcapng file filter_expression: Scapy-style filter expression max_packets: Maximum packets to scan (default: 100000) max_results: Maximum matching packets to return (default: 100)

Returns: Matching packets with details and filter summary

Inputs: file_path (required), filter_expression (required), max_packets, max_results.

dns_lookupA

Perform DNS lookup for a hostname or reverse lookup for an IP.

Use this tool to resolve hostnames to IP addresses, find mail servers (MX), or perform reverse DNS lookups.

Args: query: Hostname to lookup (e.g., "google.com") or IP for reverse lookup record_type: DNS record type - A, AAAA, CNAME, MX, TXT, NS, SOA, PTR (default: A) nameserver: Optional specific nameserver to query (e.g., "8.8.8.8")

Returns: DNS records found with TTL and response time

Inputs: query (required), record_type, nameserver.

filter_packetsA

Filter packets from a pcap file based on criteria.

Use this tool to extract specific packets matching your criteria. Multiple filters can be combined (AND logic).

Args: file_path: Path to the pcap or pcapng file src_ip: Filter by source IP address dst_ip: Filter by destination IP address protocol: Filter by protocol (TCP, UDP, ICMP, DNS) port: Filter by port number (source or destination) max_packets: Maximum packets to scan (default: 100000) max_results: Maximum matching packets to return (default: 100)

Returns: Matching packets with details (number, timestamp, IPs, protocol, info)

Inputs: file_path (required), src_ip, dst_ip, protocol, +3 more.

find_tcp_issuesA

Analyze TCP packets for issues like retransmissions and resets.

Use this tool to diagnose network problems. Detects:

  • Retransmissions (indicating packet loss)

  • TCP resets (connection problems)

  • Zero window (buffer exhaustion)

  • Duplicate ACKs (packet loss signals)

Args: file_path: Path to the pcap or pcapng file max_packets: Maximum packets to analyze (default: 100000)

Returns: TCP issues categorized by type with severity and recommendations

Inputs: file_path (required), max_packets.

find_vlan_for_ipA

Find which VLAN subnet(s) match an IP in a provided VLAN map.

Tier 1 "hero tool":

  • "What VLAN does this IP belong to?"

Example vlan_map: {"10": "192.168.10.0/24", "20": {"cidr": "192.168.20.0/24", "name": "Voice"}}

Inputs: ip (required), vlan_map (required).

get_arp_tableA

Get the ARP table.

Use this tool to view the ARP cache showing IP to MAC address mappings for hosts on the local network. Works on Linux, macOS, and Windows.

Returns: ARP entries with IP addresses, MAC addresses, and states

Inputs: no named parameters.

get_connectionsA

Get active network connections.

Use this tool to view active TCP/UDP connections including listening ports and established connections. Works on Linux, macOS, and Windows.

Args: protocol: Filter by protocol (tcp, udp, or None for all) state: Filter by state (e.g., ESTABLISHED, LISTEN, or None for all)

Returns: Connection list with local/remote addresses, states, and process info

Inputs: protocol, state.

get_conversationsA

Extract network conversations/flows from a pcap file.

Use this tool to see which hosts are communicating and how much data they're exchanging. Useful for identifying top bandwidth consumers.

Args: file_path: Path to the pcap or pcapng file max_packets: Maximum packets to analyze (default: 100000) top_n: Return top N conversations by packet count (default: 20)

Returns: List of conversations with source/dest, protocol, packets, and bytes

Inputs: file_path (required), max_packets, top_n. Returns: result

get_dns_configA

Get DNS configuration.

Use this tool to view the configured DNS nameservers and search domains. Works on Linux, macOS, and Windows.

Returns: DNS configuration with nameservers and search domains

Inputs: no named parameters.

get_interfacesA

Get network interface information.

Use this tool to list all network interfaces on the local system with their IP addresses, MAC addresses, and status. Works on Linux, macOS, and Windows.

Returns: Interface list with IPs, MACs, status, and the default interface

Inputs: no named parameters.

get_protocol_hierarchyB

Analyze protocol distribution in a packet capture.

Use this tool to see the breakdown of protocols by packet count and bytes. Similar to Wireshark's protocol hierarchy view.

Args: file_path: Path to the pcap or pcapng file max_packets: Maximum packets to analyze (default: 100000)

Returns: Protocol hierarchy with packet counts, bytes, and percentages

Inputs: file_path (required), max_packets.

get_public_ipA

Get the public/external IP address.

Use this tool to determine the public IP address as seen from the internet. This is useful for understanding NAT configuration or verifying external connectivity. Tries multiple services for reliability.

Args: timeout: Timeout in seconds for each service request (default: 10)

Returns: Public IP address and the service used to determine it

Inputs: timeout.

get_routesA

Get the routing table.

Use this tool to view the system's routing table including default gateway, destination networks, and associated interfaces. Works on Linux, macOS, and Windows.

Returns: Routing table with destinations, gateways, interfaces, and default gateway

Inputs: no named parameters.

ip_in_subnetA

Check if an IP is in a subnet and whether it is a usable host address.

NOC use cases:

  • "Is this IP in this VLAN subnet?"

  • Catch network/broadcast mistakes (/24 .0 / .255) quickly

Inputs: ip (required), cidr (required).

ip_in_vlanA

Check if an IP belongs to a VLAN (1 subnet per VLAN) using a provided VLAN map.

If it does NOT match, this tool will attempt a best-guess VLAN match to help Tier 1/2 triage.

Example vlan_map: {"20": {"cidr": "10.10.20.0/24", "name": "Voice"}, "50": "10.10.50.0/24"}

Inputs: ip (required), vlan_id (required), vlan_map (required).

mtrA

Run MTR (My Traceroute) for detailed path analysis with statistics.

MTR combines traceroute and ping to provide per-hop packet loss and latency statistics over multiple probes. Better than traceroute for diagnosing intermittent issues.

Note: Requires MTR to be installed on the system.

Args: target: Hostname or IP address to analyze count: Number of pings to send to each hop (default: 10) timeout: Timeout in seconds (default: 5)

Returns: Per-hop statistics including packet loss percentage and latency

Inputs: target (required), count, timeout.

pcap_summaryA

Get a high-level summary of a packet capture file.

Use this tool to quickly understand what's in a pcap file without reading every packet. Returns protocol breakdown, top talkers, and basic statistics.

Args: file_path: Path to the pcap or pcapng file max_packets: Maximum packets to analyze (default: 100000)

Returns: Capture summary including packet count, duration, protocols, and top talkers

Inputs: file_path (required), max_packets.

pingA

Ping a host to check connectivity and measure latency.

Use this tool to verify if a host is reachable and measure round-trip latency. Returns packet loss percentage and latency statistics (min/avg/max).

Args: target: Hostname or IP address to ping (e.g., "google.com" or "8.8.8.8") count: Number of ICMP packets to send (default: 4) timeout: Timeout in seconds for each packet (default: 5)

Returns: Ping results including success status, packet loss, and latency statistics

Inputs: target (required), count, timeout.

plan_subnetsA

Allocate VLAN subnets from a parent IPv4 block (deterministic, no network calls).

Each requirement is 1 subnet per VLAN. Use either hosts (alias: needed_hosts) OR prefix (alias: desired_prefix).

Example: parent_cidr="10.0.0.0/23" requirements=[ {"vlan_id": 10, "name": "Users", "hosts": 120}, {"vlan_id": 20, "name": "Voice", "hosts": 60}, {"vlan_id": 30, "name": "Printers", "prefix": 26}, ]

Inputs: parent_cidr (required), requirements (required).

port_checkA

Check if a TCP port is open and optionally grab service banner.

Use this tool to verify if a service is listening on a port, check firewall rules, or identify what service is running on a port.

Args: target: Hostname or IP address to check port: TCP port number to check (1-65535) timeout: Connection timeout in seconds (default: 5) grab_banner: Whether to attempt to grab service banner (default: True)

Returns: Port status (open/closed), response time, and optional service banner

Inputs: target (required), port (required), timeout, grab_banner.

rdap_lookupB

WHOIS-style lookup using RDAP (Registration Data Access Protocol).

Use this to identify who owns an IP range or domain and to get registration metadata.

Inputs: query (required), timeout.

subnet_splitA

Split a CIDR into equal-size child subnets (by new_prefix or power-of-two count).

Inputs: cidr (required), new_prefix, count.

tracerouteA

Trace the network path to a destination, showing each hop.

Use this tool to understand the network path between you and a target, identify where latency is introduced, or find where packets are being dropped.

Args: target: Hostname or IP address to trace (e.g., "google.com") max_hops: Maximum number of hops to trace (default: 30) timeout: Timeout in seconds for each probe (default: 5)

Returns: Path analysis with hop-by-hop details including IP, hostname, and latency

Inputs: target (required), max_hops, timeout.

validate_vlan_mapA

Validate a simple VLAN map (1 subnet per VLAN) and surface overlaps.

Input formats supported:

  • Shorthand: {"10": "192.168.10.0/24"}

  • Structured: {"10": {"cidr": "192.168.10.0/24", "name": "Management"}}

Inputs: vlan_map (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 34 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, such as DNS lookups (single vs batch), connectivity tests (ping, batch_ping, mtr, traceroute), pcap analysis (filter, custom filter, DNS, TCP issues, conversations, hierarchy, summary), and CIDR/VLAN operations. No two tools overlap in a way that would confuse an agent.

    Naming Consistency5/5

    All tools follow a consistent snake_case verb_noun pattern (e.g., dns_lookup, batch_ping, filter_packets, get_interfaces). There is no mixing of conventions or vague verbs, making the namespace predictable.

    Tool Count2/5

    With 34 tools, the count exceeds the 'too many' threshold of 25+ as per the rubric. While each tool serves a distinct purpose, the sheer number may overwhelm agents, and the server scope could be narrowed or grouped without losing functionality.

    Completeness5/5

    The tool surface covers the full lifecycle of network troubleshooting: DNS, ICMP, TCP, pcap analysis, CIDR planning, VLAN validation, system information, and more. There are no obvious gaps for the stated domain of network operations.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A Model Context Protocol server that provides LLM Agents with a comprehensive toolset for IP geolocation, network diagnostics, system monitoring, cryptographic operations, and QR code generation.
      5
      433 npm
      20
      Apache 2.0
    • A
      license
      B
      quality
      D
      maintenance
      A Model Context Protocol server that provides LLMs with real-time network traffic analysis capabilities, enabling tasks like threat hunting, network diagnostics, and anomaly detection through Wireshark's tshark.
      7
      608
      MIT
    • A
      license
      C
      quality
      D
      maintenance
      A Model Context Protocol server that provides network analysis tools for security professionals, enabling AI models like Claude to perform tasks such as ASN lookups, DNS analysis, WHOIS retrieval, and IP geolocation for security investigations.
      4
      1
      Apache 2.0
    • A
      license
      A
      quality
      Not graded
      maintenance
      A Model Context Protocol server that provides network packet capture and analysis capabilities through Wireshark/tshark integration, enabling AI assistants to perform network security analysis and troubleshooting.
      4
      36
      MIT