eos-mcp
Summary: An MCP server that lets an AI assistant inspect, run commands on, and safely change configuration of Arista EOS switches over eAPI.
Server/inventory checks —
health_check(version + config status, no device contact),get_router_list(devices, optional tag filter).Device facts —
get_device_facts/get_device_facts_batch(model, serial, EOS version, uptime, memory) andget_versionas a quick connectivity probe.Command execution —
run_command,run_commands,run_command_batch,run_commands_batch; enable-mode commands passed verbatim, targeted by hostname or tags (fleet-wide, parallel).Config visibility —
get_config(running-config),get_config_diff(vs a rollback checkpoint),list_config_sessions(pending / commit-timer / completed sessions).Guarded config changes —
push_configstages lines in a named configure session and, by default (dry_run=True), only shows a diff and aborts; withdry_run=Falseit commits under a rollback timer, thenconfirm_config_sessionfinalizes orabort_config_sessiondiscards.Diagnostics —
collect_tech_support(large, 30+ s output) anddaily_brief(Markdown CRITICAL/WARNING/OK report on environment, errdisabled ports, uptime, MLAG, and recent syslog alerts).Worth noting: anything requiring privilege fails cleanly if the
config.iniaccount is show-only, but therun_command*tools are not limited toshow ...— they reach the same write path aspush_configwithout its dry-run/commit-timer safety net.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@eos-mcp show running config on switch1.example.com"
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.
eos-mcp
English | 日本語
MCP server for Arista EOS device operations via eAPI.
Exposes EOS show commands, running-config retrieval, configuration push (via configure session with commit timer), and tech-support collection to MCP-compatible AI assistants.
Documentation: https://shigechika.github.io/eos-mcp/
Installation
pip install eos-mcpRelated MCP server: Network MCP Lab
Configuration
Copy config.ini.example to ~/.config/eos-mcp/config.ini and fill in credentials:
[DEFAULT]
username = admin
password = yourpassword
transport = https
verify = false
[switch1.example.com]
tags = main,dc1
[switch2.example.com]
tags = main,dc1Config file discovery order:
EOS_MCP_CONFIGenvironment variable./config.ini(current directory)~/.config/eos-mcp/config.ini
(Individual MCP tool calls may also override the path via a config_path
parameter.)
Write operations
Three tools change device state through a guarded path:
Tool | API call | Gated by |
| Opens a | The eAPI account's own EOS privilege level: it must be able to enter |
|
| Same EOS account privilege requirement as |
|
| Same EOS account privilege requirement as |
Give the config.ini account for a device a lower-privilege, show-only role
and these three tools fail against the EOS API instead of writing; every
read-only tool for that device keeps working.
run_command, run_commands, run_command_batch, and
run_commands_batch are not restricted to show ... commands, despite
being documented and grouped as command runners. Nothing in the server
validates or whitelists the command text — it is passed to the eAPI Command
API verbatim — so these tools can execute arbitrary enable-mode EOS
commands, including configure terminal ... or reload, on any configured
device (a single host, or fleet-wide via tags in the _batch variants).
This is gated by the same EOS account privilege as push_config, but
without push_config's dry_run / commit-timer safety net — a de facto
second write path worth remembering when deciding how privileged a device's
config.ini account should be.
Usage
Claude Code (plugin)
This repository doubles as a single-plugin marketplace, so Claude Code can install the server for you:
/plugin marketplace add shigechika/eos-mcp
/plugin install eos-mcp@eos-mcpThe plugin launches uvx eos-mcp and reads EOS_MCP_CONFIG, the same
variable described in Configuration. Leave it unset and
the server falls through to its normal discovery order (./config.ini,
then ~/.config/eos-mcp/config.ini). /plugin install only wires up the
server process — it cannot create the config.ini file or the per-device
eAPI credentials it holds; that file must already exist on the machine
running the plugin before any tool but health_check will succeed.
uvx must be on the PATH of the process that runs Claude Code — a login
shell usually has it, but a GUI-launched app may not; install
uv system-wide if the plugin fails to start.
Claude Code (manual)
In .mcp.json:
{
"mcpServers": {
"eos-mcp": {
"type": "stdio",
"command": "eos-mcp"
}
}
}Add "env": { "EOS_MCP_CONFIG": "..." } only if config.ini is not at one
of the default discovery locations above.
Claude Desktop
Add the same entry to claude_desktop_config.json.
Codex
codex mcp add eos-mcp -- eos-mcpAdd --env EOS_MCP_CONFIG=... (before --) only if config.ini is not at
one of the default discovery locations above.
Any other MCP client that launches stdio servers works the same way: give it
eos-mcp as the command.
From a shell
# Verify config and list devices
eos-mcp --check
# Test connectivity to a specific host
eos-mcp --check --check-host switch1.example.com
# Start MCP server (stdio transport)
eos-mcpTools
Tool | Description |
| Report server version and config status (lightweight; does NOT connect to devices) |
| List registered devices (optional tag filter) |
| Return structured facts for one device (model, serial, EOS version, uptime, memory) |
| Return device facts for multiple devices in parallel |
| Return EOS version string (quick connectivity check) |
| Run a single enable-mode command on one device |
| Run multiple enable-mode commands on one device |
| Run an enable-mode command on multiple devices in parallel |
| Run multiple enable-mode commands on multiple devices in parallel |
| Retrieve running-config |
| Show config diff vs rollback checkpoint |
| List configure sessions and their state |
| Push config via configure session (dry_run=True by default) |
| Confirm a pending commit timer session |
| Abort a pending session |
| Collect show tech-support output |
| Health check (environment, errdisabled, uptime, MLAG, recent syslog alerts) across multiple devices |
Development
Live smoke test
Unit tests check logic against fixtures; they cannot tell you that a tool has
stopped returning real data. scripts/smoke_test.py runs every registered
tool against the configured devices and fails on empty, malformed or error
answers:
# uses the same inventory file as the server (EOS_MCP_CONFIG)
uv run python scripts/smoke_test.py
uv run python scripts/smoke_test.py --only facts --tracebackRead-only.
push_config,confirm_config_sessionandabort_config_sessionare skipped by name, and a test enforces that.collect_tech_supportis skipped too — it changes nothing, but it is minutes of device CPU for an answer no assertion would read. The command-running tools are exercised withshow version: they accept enable-mode commands in general, and a smoke test must not be the thing that types one that matters.No payloads in the report. Tool names and statuses only; error text is redacted too, since every error here is prefixed with the device it came from and the payloads are configuration.
Nothing estate-specific in the specs. The device the per-host tools need is discovered at run time from the configured inventory, and skipped when it is empty. Two tests keep it that way: one refuses those parameters as literals, the other bans anything address-shaped anywhere in the file, because this repository is public.
Every probe refuses the
Error (<host>): ...line these tools return in place of raising — otherwise an unreachable device would read as a successful call.CI enforces the cheap half: a tool registered without a probe spec fails the build (
tests/test_smoke_probes.py), so adding a tool forces the question "how would we know it works?".scripts/smoke_harness.pyis the engine and holds no EOS knowledge: it is kept identical across the servers that share it, so fix engine bugs once and sync the file rather than patching this copy.
Requirements
Python >= 3.11
Arista EOS with eAPI enabled (
management api http-commands)Network access to port 443 (HTTPS) on target devices
License
Apache-2.0
Available Tools
17 toolsabort_config_sessionC
Abort a pending configure session on an EOS device.
Inputs: hostname (required), config_path, session_name. Returns: result
collect_tech_supportB
Collect show tech-support from an EOS device (large output, 30+ seconds).
Inputs: hostname (required), config_path. Returns: result
confirm_config_sessionB
Confirm (finalize) a pending configure session commit timer on an EOS device.
Inputs: hostname (required), config_path, session_name. Returns: result
daily_briefA
Run health checks on EOS devices and return a Markdown daily brief.
Checks environment (temperature, cooling, fans, PSUs), errdisabled interfaces, device uptime, MLAG status, and recent syslog alerts (BGP/OSPF/STP/LACP/MLAG/ link-down) within the last 'since_hours' hours. Returns CRITICAL/WARNING/OK per device with a summary. Specify targets via 'hostnames', 'tags', or both (default: all configured devices).
Inputs: tags, hostnames, config_path, max_workers, +1 more. Returns: result
get_configC
Retrieve the running-config from an EOS device.
Inputs: hostname (required), config_path. Returns: result
get_config_diffA
Show config diff on an EOS device.
rollback_id=1 (default) → diff vs most recent rollback checkpoint. rollback_id=N → diff vs Nth rollback checkpoint. Note: diff vs startup-config requires EOS 4.30+; older versions fall back gracefully.
Inputs: hostname (required), config_path, rollback_id. Returns: result
get_device_factsC
Return structured device facts: hostname, model, serial, EOS version, uptime, memory.
Inputs: hostname (required), config_path. Returns: result
get_device_facts_batchA
Return device facts (model, serial, EOS version, uptime) for multiple devices in parallel.
Inputs: tags, hostnames, config_path, max_workers. Returns: result
get_router_listB
List EOS devices registered in config, optionally filtered by tags.
Inputs: tags, config_path. Returns: result
get_versionA
Return EOS version string for a device (quick connectivity check).
Inputs: hostname (required), config_path. Returns: result
health_checkA
Report server version and configuration status (lightweight).
Call this at session start (or after a tool-call timeout) to confirm the MCP is up, see which version is running, and verify the device inventory config loads. Lightweight: it only reads and parses config.ini — it does NOT open any eAPI/pyeapi connection to EOS devices, so it is safe to call against a large fleet without touching the network.
Always returns the same keys: status (healthy / degraded / error),
service, version, config_path (resolved config.ini path),
device_count (EOS hosts in config), tags (sorted distinct tags), and
config (ok / error / missing). On a degraded or error result, detail
carries the reason.
Inputs: config_path.
list_config_sessionsA
List configure sessions and their state on an EOS device.
Shows pending, pendingCommitTimer, and completed sessions. Useful for tracking in-flight push_config operations.
Inputs: hostname (required), config_path. Returns: result
push_configA
Push configuration to an EOS device via a named configure session.
When dry_run=True (default) shows diffs and aborts — no changes applied. When dry_run=False commits with a rollback timer (default 300 seconds). Call confirm_config_session before the timer expires to finalize.
Inputs: hostname (required), config_lines (required), dry_run, config_path, +2 more. Returns: result
run_commandB
Run a single enable-mode command on an EOS device and return text output.
Inputs: command (required), hostname (required), config_path. Returns: result
run_command_batchA
Run an enable-mode command on multiple EOS devices in parallel.
Specify targets via 'hostnames', 'tags', or both.
Inputs: command (required), tags, hostnames, config_path, +1 more. Returns: result
run_commandsB
Run multiple enable-mode commands on one EOS device and return labelled output.
Inputs: commands (required), hostname (required), config_path. Returns: result
run_commands_batchA
Run multiple enable-mode commands on multiple EOS devices in parallel.
Specify targets via 'hostnames', 'tags', or both. Each device's output is labelled by hostname and command.
Inputs: commands (required), tags, hostnames, config_path, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 17 tools
Each tool targets a specific resource and action: device inventory, facts, commands, configuration, sessions, and health. The only potential overlap is get_version vs get_device_facts, but the descriptions clearly distinguish the quick connectivity check from full facts. Batch variants are clearly differentiated by scope (single/multiple devices, single/multiple commands).
The majority of tools follow a consistent verb_noun snake_case pattern (get_, list_, run_, push_, confirm_, abort_, collect_). A few names like health_check and daily_brief deviate from this pattern, but they are still readable and recognizable. Overall, the convention is predictable with minor exceptions.
With 17 tools, the server is slightly above the ideal 3-15 range but still well-scoped for the domain of EOS device management. Each tool covers a distinct operational need, from inventory to configuration sessions to health monitoring. The count feels reasonable for a comprehensive network device MCP server.
The tool surface covers the core lifecycle: discover devices, retrieve facts, run commands, get/push config, manage config sessions, and monitor health. Minor gaps include no explicit save-config to startup and no device inventory update, but these can be worked around via command execution or configuration changes. Overall, the set is quite complete for common automation workflows.
Maintenance
Related MCP Connectors
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Authenticated MCP server for ClearPolicy policy and compliance workflows.
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Related MCP Servers
- AlicenseCqualityBmaintenanceA Python-based MCP server that enables querying Cisco's Meraki Dashboard API to discover, monitor, and manage Meraki environments.2247MIT
- FlicenseNot gradedqualityDmaintenanceMCP server for executing show commands and managing Cisco IOS-XE network devices via async SSH using Scrapli.6-
- FlicenseAqualityDmaintenanceA local MCP server for interacting with a network lab, supporting read-only and configuration tools for devices like Arista EOS switches.6-
- -licenseNot gradedqualityNot gradedmaintenanceEnables querying and interacting with Arista CloudVision via MCP, supporting both HTTP and gRPC connections.6-