Topolograph
Server Details
OSPF and IS-IS topology, paths, failure impact, change events, MPLS TE and BGP from Topolograph
- Status
- Healthy
- Uptime
- 66.7% over the last 24 hours
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- Vadims06/topolograph-mcp-server
- GitHub Stars
- 6
- Server Listing
- Topolograph MCP Server
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 32 tools
Most tools have clearly distinct resource/action targets, and descriptions explicitly disambiguate potentially confusing pairs such as get_adjacency_events vs get_events_timeline and get_shortest_path vs get_cspf_path. A few read-only query tools (get_routes, search_bgp_routes, resolve_route; get_all_graphs, get_graph_by_time) require careful reading to choose correctly, but overall overlap is low.
Tool names consistently use snake_case with predictable verb_noun structure (get_*, list_*, compare_*, search_*, resolve_route). The get/list split for collection retrieval is minor and still readable; there is no chaotic mixing of casing or verb styles.
The 32 tools cover a genuinely broad platform (IGP graphs, BGP/BMP, EVPN/VPNs, TE LSPs, events, failure simulation), so they are not arbitrary. However, the count is well above the ideal 3–15 range and increases selection overhead even with good descriptions.
The surface is broad and cohesive for a read-only topology analysis server: graphs, nodes, edges, networks, events, paths, LSPs, BGP, VPN inventory, and failure simulation are all covered. Obvious gaps are write/ingestion operations (upload graph, create/delete resources) and some per-node/per-edge drill-down might require filters or workarounds, but core analysis workflows are complete.
Available Tools
32 toolscompare_bgp_routesARead-onlyIdempotentInspect
Diff BGP routes between two instants: one row per differing route.
Input fields: bgp_graph_time (str): The BGP graph epoch to query (the t1 epoch) t0 (str): ISO 8601 timestamp, the earlier instant t1 (str): ISO 8601 timestamp, the later instant router_id (str, optional): Scope the diff to one reporting speaker t0_graph_time (str, optional): Epoch of t0 when it differs from bgp_graph_time (collector restart); must be the same collector
Output fields: dict with key: items (list of BgpRouteDiffRow; diff_status is added|withdrawn|changed, a changed row also carries diff_prev). There is no total: count the rows per diff_status and quote those counts.
Equivalent to GET /bgp-graph/{bgp_graph_time}/routes/compare.
Inputs: t0 (required), t1 (required), bgp_graph_time (required), router_id, +1 more. Returns: items
get_adjacency_eventsARead-onlyIdempotentInspect
Description: This tool returns links/adjacencies events including nodes/hosts up/down events. Use this tool only to get details about nodes/hosts events. Events exist ONLY for watcher-monitored graphs (is_monitored=true). Manually uploaded or YAML graphs are not monitored and have no events; first call get_all_graphs(is_monitored=true, latest_only=true) to pick a monitored graph_time. Treat any cost change to or from -1 as down (падение) or up (восстановление) event.
Input fields: graph_time (str): Name of graph = The graph time to filter events. start_time (str, optional): Start time to filter events in ISO format (e.g., 2025-06-30T20:00:00Z) end_time (str, optional): End time to filter events in ISO format. Defaults to current time if not provided. last_minutes (int, optional): Number of minutes to look back from current time for events. If provided, overrides start_time and end_time parameters.
Output fields: AdjacencyEventsResponse: A dictionary containing adjacency event information with keys: - all_host_up_down_events: List of all Up/Down nodes/hosts events (Восстановление узла, Падение узла). List includes all events even recovered events (when node is up after being down). - single_host_up_events: List of Up nodes/hosts events (Восстановление узла) from the time when graph was collected. - single_host_down_events: List of Down nodes/hosts events (Падение узла) from the time when graph was collected. - adjacency_cost_change_events: List of link/adjacency cost (or other metrics) change events (изменение стоимости линка)
Equivalent to GET /events/{graph_time}/adjacency.
Inputs: graph_time (required), end_time, start_time, last_minutes. Returns: single_host_up_events, all_host_up_down_events, single_host_down_events, adjace…
get_all_graphsARead-onlyIdempotentInspect
Description: This tool retrieves available graphs from the Topolograph API with optional filtering. This tool is a first step for all analysis. Each graph reports two monitoring flags: - is_monitored: the graph was received from a watcher (vs manually uploaded). Only monitored graphs have events; use is_monitored=true when answering change/event questions. - is_live: the source watcher is currently sending heartbeats.
Input fields: protocol (str, optional): Filter graphs by protocol (ospf, ospfv3, isis, yaml) area (str, optional): Filter graphs by area number is_monitored (bool, optional): true = only watcher-received graphs, false = only manually uploaded name (str, optional): Case-insensitive substring over graph_time or watcher_name (e.g. "before_maintenance") latest_only (bool, optional): Return only the single newest graph among those matching the filters page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50)
Output fields: dict with keys: items: list of graphs, each with is_monitored and is_live flags pagination: page, per_page, total, total_pages
Equivalent to GET /graph with query parameters.
Inputs: area, name, page, per_page, +3 more. Returns: object
get_bgp_bindingBRead-onlyIdempotentInspect
Fetch one BGP-to-IGP graph binding: which IGP graph this BGP epoch is correlated with, and how confidently (matched_rids, source_coverage, state).
Equivalent to GET /bgp-graph/{bgp_graph_time}/{graph_time}/binding.
Inputs: graph_time (required), bgp_graph_time (required). Returns: state, matched_rids, bgp_graph_time, igp_graph_time, +1 more
get_bgp_events_timelineARead-onlyIdempotentInspect
BGP monitoring events (session up/down, route churn), grouped into a timeline by default.
Input fields: bgp_graph_time (str): The BGP graph epoch to query start_time (str, optional), end_time (str, optional): ISO 8601 window last_minutes (int, optional): Look back this many minutes from end_time (default now); overrides start_time event_name (str, optional), event_status (str, optional): Filters as_rows (bool, optional): Return one flat row per event instead of the timeline aggregate
Equivalent to GET /bgp-graph/{bgp_graph_time}/events.
Inputs: bgp_graph_time (required), as_rows, end_time, event_name, +3 more. Returns: object
get_bgp_graphBRead-onlyIdempotentInspect
Fetch one BGP graph epoch by bgp_graph_time.
Equivalent to GET /bgp-graph/{bgp_graph_time}.
Inputs: bgp_graph_time (required). Returns: nodes, sessions, timestamp, graph_time
get_bgp_node_route_summaryARead-onlyIdempotentInspect
Route totals for one BGP speaker: its resolved RIB view size, a per-RIB-tag histogram, and how many routes it advertised (Adj-RIB-Out).
Equivalent to GET /bgp-graph/{bgp_graph_time}/node/{router_id}/routes/summary.
Inputs: router_id (required), bgp_graph_time (required). Returns: total, by_ribs, rib_view, adj_rib_out
get_bgp_route_stateBRead-onlyIdempotentInspect
Point-in-time BGP route state, reconstructed from stored events.
Input fields: bgp_graph_time (str): The BGP graph epoch to query at (str, optional): ISO 8601 timestamp; defaults to now
Equivalent to GET /bgp-graph/{bgp_graph_time}/routes/state.
Inputs: bgp_graph_time (required), at. Returns: object
get_cspf_pathARead-onlyIdempotentInspect
Constrained-shortest-path (CSPF) query between two nodes.
Description: Answers "will an LSP with these constraints fit, and which path would it take" -- an on-demand computation, exactly like get_shortest_path, just over a graph pre-filtered by the given TE constraints instead of the plain one. No tunnel is created or persisted; this never mutates the graph. Use this before calling add_lsp when you want to check feasibility first.
Input fields: graph_time (str): The graph time identifier node_a (str): Source node name node_b (str): Destination node name bandwidth (str, optional): Required bandwidth, e.g. "2G", "500M", or a raw bps number metric_type (str, optional): "igp" (default) or "te" admin_exclude_any (list[str], optional): Admin groups to exclude. On an IS-IS graph a group is the number of a bit of the link's admin group mask (bit 0 is the least significant; "2" avoids mask 0x00000004); on a YAML diagram it is an affinity name admin_include_any (list[str], optional): Admin groups, at least one required admin_include_all (list[str], optional): Admin groups, all required srlg_exclude (list[int], optional): SRLG ids to exclude setup_priority (int, optional): RSVP-TE setup priority (0-7, default 7) -- selects which advertised Unreserved Bandwidth pool the bandwidth check runs against level (int, optional): IS-IS level, 1 or 2. Restricts the path to links that advertised their TE data at that level; omit for no level restriction. No effect on a non-IS-IS graph. Fails with isis_level_calculation_unavailable on a graph stored before per-level IS-IS data existed (re-upload the LSDB), and with isis_level_unavailable_for_yaml_diagram on a YAML diagram
Output fields: CspfPathResponse: dict with keys: - path: list of node names (empty if no path satisfies the constraints) - cost: total path metric (null if unplaced) - reason: why placement failed, e.g. which constraint removed the only path (empty string on success)
Equivalent to GET /graph/{graph_time}/cspf-path/{node_a}/{node_b}.
Inputs: node_a (required), node_b (required), graph_time (required), level, +7 more. Returns: cost, path, reason
get_edge_failure_reactionARead-onlyIdempotentInspect
Predict the whole-network impact if one or more links go down.
Description: Same shape as get_node_failure_reaction, for links instead of nodes: whether the graph stays connected, and the traffic rerouting pattern (which links see more/less traffic). This is a simulation only: it does not fail any link or otherwise mutate the graph.
Input fields: graph_time (str): The graph time failed_edges (list[list[str]]): Pairs of node names identifying each failed link, e.g. [["10.10.10.1", "10.10.10.2"]]
Output fields: NetworkReactionResponse: dict with keys: - isGraphStillConnected: bool - affectedLinks: {sptPathsIncreasedInPercent, sptPathsDecreasedInPercent}, each a list of {edge_key, from, to, value}, one per link direction, value in percent - disjointedNodes: list of node-name groups, if the graph split
Equivalent to POST /network-reaction/edge-failure/.
Inputs: graph_time (required), failed_edges (required). Returns: affectedLinks, disjointedNodes, isGraphStillConnected
get_edgesARead-onlyIdempotentInspect
Get edges from a graph with optional filtering.
Description: Returns a paginated list of edges. Supports graph-level pre-filters (protocol, watcher, area) and per-edge attribute filters. Useful for queries like "all IS-IS L1 edges" or "edges with max_rsrv_link_bw < 10Gbps". Edges are the source of neighbor/adjacency data: to find a router's neighbor count, fetch edges and count those with that router as src_node. Results are paginated; read all pages (see pagination.total_pages) before counting.
Attribute filters use exact match or range operators:
weight=10, temetric__gt=100, unreserved_bw_0__lt=1000000000
TE attributes (when present): temetric, admin_group, max_link_bw,
max_rsrv_link_bw, unreserved_bw_0..7
IS-IS: isis_level=1 or isis_level=2
User-defined attributes (e.g. isp_provider=verizon) are also supported.Input fields: graph_time (str): The graph time identifier, or the name of your OSPF/IS-IS watcher (Enterprise) to read its newest snapshot with events up to now; the answer then names that snapshot in graph_time src_node (str, optional): Filter edges by source node name dst_node (str, optional): Filter edges by destination node name protocol (str, optional): Graph-level filter (ospf, ospfv3, isis, yaml) watcher (bool, optional): Graph-level filter: watcher-uploaded vs manually parsed area (str, optional): Graph-level filter by area edge_query_params (dict, optional): Edge attribute filters (flat key=value pairs) include (list[str], optional): Extra MPLS-TE fields, hidden by default: "lsp_left_bw" (how much TE bandwidth is left on each edge, after accounting for placed LSP tunnels -- lsp_left_bw_0..7 plus a human-readable lsp_reserved_bw/lsp_left_bw/lsp_bandwidth_usage pair at the default priority-7 pool), "lsps" (which LSP tunnels traverse this edge), "is_te_link" (true when the link advertises at least one optional TE value: TE metric, admin group, max/reservable/unreserved bandwidth or SRLG; a zero counts, interface and neighbor addresses do not), "edge_key" (stable identity, needed for get_lsps(via_edge_key=) on parallel/ECMP edges) page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50) is_te_link (bool, optional): true keeps only TE links, false only links that are not; any other type is rejected with HTTP 400 at (str, optional): ISO 8601 moment; state with watcher events applied up to it
Output fields: dict with keys: items: list of edges with src, dst, weight, and optional TE/IS-IS/user-defined attrs pagination: page, per_page, total, total_pages
Equivalent to GET /graph/{graph_time}/edges.
Inputs: graph_time (required), at, area, page, +8 more. Returns: object
get_events_timelineARead-onlyIdempotentInspect
Description: This tool returns node/host up/down events already grouped into chronological time waves (server-side), so you can narrate a network incident ("instability started at T from device X; a flapping burst from device Y; reconverged at T+n") without scanning hundreds of raw events. Waves hold adjacency up/down only: metric (cost) changes are not in them, so for "what happened" also call get_adjacency_events for the same window and report its cost changes with the waves. Events exist ONLY for watcher-monitored graphs (is_monitored=true); first call get_all_graphs(is_monitored=true, latest_only=true). Returns wave summaries only (no nested event arrays): to get a wave's individual events, call get_adjacency_events with that wave's start_ts/end_ts.
Input fields: graph_time (str): The graph time to filter events. start_time (str, optional): Start time in ISO format (e.g., 2025-06-30T20:00:00Z) end_time (str, optional): End time in ISO format. Defaults to current time if not provided. last_minutes (int, optional): Look back this many minutes; overrides start_time/end_time. page (int, optional): Page number (1-indexed) over the waves list. per_page (int, optional): Number of waves per page.
Output fields: EventsTimelineResponse: A dictionary with keys: - graph_time, watcher_name - gap_multiplier, median_gap_sec: how the grouping was computed - waves: list of per-wave summaries, each with wave_number, start_ts, end_ts (ISO 8601, reusable as start_time/end_time), duration_sec, event_count, distinct_devices, trigger_device, pattern ("outage" left down / "flap" down then up / "up" only ups), converged (recovery seen within the queried window; a recovery after end_time is not counted) - pagination: page, per_page, total, total_pages
Equivalent to GET /events/{graph_time}/adjacency/timeline.
Inputs: graph_time (required), page, end_time, per_page, +2 more. Returns: waves, graph_time, pagination, watcher_name, +2 more
get_graph_analysisARead-onlyIdempotentInspect
Whole-graph report: central routers, most loaded links, single points of failure and more.
Input fields: graph_time (str): The graph time kind (str): central-nodes, most-loaded, single-point-of-failure, fault-tolerant, heatmap, unsym-paths, unidir-edges, backup-paths-in-ecmp, duplicated-terminated-networks or network-score at (str, optional): ISO 8601 moment; a watcher graph is shown with the events up to it
Output fields: dict with result, nodes and edges. The routers and links the report names are in nodes and edges; backup-paths-in-ecmp and duplicated-terminated-networks list rows in result.rows; network-score answers result.total, max, percentage and details.
Equivalent to GET /graph/{graph_time}/analyse/{kind}.
Inputs: kind (required), graph_time (required), at. Returns: object
get_graph_by_timeBRead-onlyIdempotentInspect
Fetch a graph by graph name from Topolograph API. graph name is a string with included date and hours and number of hosts, i.e 01Sep2025_12h44m36s_8_hosts
graph_time (str, optional): The graph time to filter by. Use latest if it's not specified.
Inputs: graph_time (required).
get_graph_statusBRead-onlyIdempotentInspect
Get the status of a graph based on its health.
Description: This tool returns the status of a graph including connectivity information and various event counts.
Input fields: graph_time (str): Name of graph = The graph time to get status for.
Output fields: dict: A dictionary containing status information with keys: - status: The overall status (ok, warning, critical, no_monitoring_data) - details: Dictionary with detailed information including: - is_connected: Boolean indicating if graph is connected (Полносвязный граф) - up_node_events: Count of node up events (Восстановление узла) - down_node_events: Count of node down events (Падение узла) - all_host_up_down_events: Count of all host up/down events - network_up_down_events: Count of network up/down events (Падение сети) - adjacency_cost_change_events: Count of adjacency cost change events (изменение стоимости линка) - top_unstable_devices: Top-N [{device, event_count}] sorted desc (самые нестабильные устройства)
Equivalent to GET /graph/{graph_time}/status.
Inputs: graph_time (required). Returns: object
get_lspsARead-onlyIdempotentInspect
List MPLS TE LSP tunnels, or get one tunnel by name.
Description: Each returned path already carries its last CSPF placement outcome: placed (bool), reason (human-readable explanation, null when placed), reason_code (machine-readable failure category, null when placed), binding_constraints (which constraints actually block it), cost (total path metric, null when unplaced).
Act on reason_code, not on the wording of reason:
disconnected -- no path exists even with every constraint lifted;
the topology is severed and must be repaired.
constraints_unsatisfiable -- a path DOES exist, but the request is
too strict. Do not tell the user connectivity is broken; tell them
which of binding_constraints to relax (bandwidth, affinity, srlg).
More than one entry means they block only in combination, so
relaxing just one will fail again.
ero_strict_hop_unreachable -- a strict ERO hop has no direct edge.
endpoint_not_found -- src or dst is not in the graph.
Getting a single tunnel by lsp_name always
includes each path's expanded node-name path; the list form omits it
by default (include_path=True to get it there too, since it can be
large across many tunnels).Input fields: graph_time (str): The graph time identifier lsp_name (str, optional): Get one tunnel by name instead of listing all status (str, optional): "placed" or "unplaced" -- keep only paths matching via_node (str, optional): Keep only paths whose CSPF-computed path visits this node (e.g. "which tunnels cross router X", pre-maintenance impact check) via_edge (str, optional): "srcNode,dstNode" -- keep only paths traversing this hop via_edge_key (str, optional): Exact stable edge_key (from get_edges(include=["edge_key"])) -- disambiguates parallel/ECMP edges that via_edge alone cannot include_path (bool, optional): Also return each path's expanded node-name path in the list form
Equivalent to GET /graph/{graph_time}/lsps[/{lsp_name}].
Inputs: graph_time (required), status, lsp_name, via_edge, +3 more. Returns: object
get_network_by_graph_timeARead-onlyIdempotentInspect
Fetch network data by explicit graph_time.
Description: This tool retrieves network information for a specific graph time. Universal tool that works with both OSPF and IS-IS protocols. Use 'node_id' to find all networks terminated by a specific node. Use 'ip_address' to find which network a specific IP belongs to.
Input fields: graph_time (str): REQUIRED - The specific graph time to query, use the most latest from get_all_graphs to get graph_time. network_w_digit_mask (str, optional): Network with mask (e.g., 10.0.0.0/24). Helpful when needed to find all devices which terminate the network ip_address (str, optional): IP address to find which network it belongs to node_id (str, optional): Universal node identifier to find all networks terminated by this node. Exact match only (no hostname or case-insensitive lookup here). - For OSPF: Use Router ID (e.g., "10.10.10.1") - For IS-IS: Use System ID (e.g., "1921.6800.1001") filter_type (str, optional): all, backuped_only or non_backuped_only; lists the networks of the graph by backup status, not with the three fields above at (str, optional): ISO 8601 moment; state with watcher events applied up to it. Not with the three lookup fields page, per_page (int, optional): page of the list read with filter_type or at; check pagination.total
Output fields: dict: A dictionary containing network information.
Examples: - get_network_by_graph_time("graph123", node_id="10.10.10.1") # All networks terminated by OSPF Router ID - get_network_by_graph_time("graph123", node_id="1921.6800.1001") # All networks terminated by IS-IS System ID - get_network_by_graph_time("graph123", ip_address="192.168.1.5") # Find network for IP 192.168.1.5
Equivalent to GET /network/{graph_time}, or GET /graph/{graph_time}/networks with filter_type or at.
Inputs: graph_time (required), at, page, node_id, +4 more.
get_network_eventsARead-onlyIdempotentInspect
Description: This tool returns networks events: network up/down and network cost change events. Use this tool only to get details about networks events. Events exist ONLY for watcher-monitored graphs (is_monitored=true). Manually uploaded or YAML graphs are not monitored and have no events; first call get_all_graphs(is_monitored=true, latest_only=true) to pick a monitored graph_time. Treat any cost change to or from -1 as down (падение) or up (восстановление) event.
Input fields: graph_time (str): Name of graph = The graph time to filter events. start_time (str, optional): Start time to filter events in ISO format (e.g., 2025-06-30T20:00:00Z) end_time (str, optional): End time to filter events in ISO format. Defaults to current time if not provided. last_minutes (int, optional): Number of minutes to look back from current time for events. If provided, overrides start_time and end_time parameters.
Output fields: NetworkEventsResponse: A dictionary containing network event information with keys: - network_up_down_events: List of NetworkUpDownEvent objects - network_cost_change_events: List of NetworkMetricChangeEvent objects
Equivalent to GET /events/{graph_time}/networks.
Inputs: graph_time (required), end_time, start_time, last_minutes. Returns: network_up_down_events, network_cost_change_events
get_node_failure_reactionARead-onlyIdempotentInspect
Predict the whole-network impact if one or more routers go down.
Description: Whether the graph stays connected and which links see more or less traffic once these routers fail. A simulation only: nothing is changed in the graph.
Input fields: graph_time (str): The graph time failed_nodes (list[str]): Node names of the failed routers, e.g. ["10.10.10.2"]
Output fields: NetworkReactionResponse: the same keys as get_edge_failure_reaction.
Equivalent to POST /network-reaction/node-failure/.
Inputs: graph_time (required), failed_nodes (required). Returns: affectedLinks, disjointedNodes, isGraphStillConnected
get_nodesARead-onlyIdempotentInspect
Get a paginated list of nodes/routers from a graph.
Description: Returns structured node data including hostname, system ID, network count, areas, IS-IS flag, and node_attributes (role flags). Supports pre-filtering by protocol, watcher origin, area, and node role flag before returning results. Note: 'network count' is the number of prefixes/networks on a node, NOT its neighbor/adjacency count. To count neighbors per router, use get_edges and count edges per src_node; do not derive neighbor counts from this tool. protocol="bgp" answers "which leaves carry VNI/VRF X" (vni/vrf/rt) and "which routers are BGP speakers" -- rows then carry can_build_path instead of the IGP node fields above.
Input fields: graph_time (str): The graph time identifier, or the name of your OSPF/IS-IS watcher (Enterprise) to read its newest snapshot with events up to now; the answer then names that snapshot in graph_time protocol (str, optional): Filter: only return if graph matches protocol (ospf, ospfv3, isis, yaml, bgp) watcher (bool, optional): Filter: true for watcher-uploaded graphs, false for manually parsed area (str, optional): Filter: only return if graph contains this area (e.g. "0", "0.0.0.1", "49.0001") abr (bool, optional): OSPF role filter — true returns only Area Border Routers (false: only non-ABRs) asbr (bool, optional): OSPF role filter — true returns only AS Boundary Routers (false: only non-ASBRs) overload (bool, optional): IS-IS filter — true returns only routers with the overload (OL) bit set attached (bool, optional): IS-IS filter — true returns only routers with the attached (ATT) bit set maxmetric (bool, optional): OSPF filter — true returns only routers in max-metric (RFC 3137 stub router) state vni (int, optional): protocol="bgp" only -- keep the routers that are a VTEP for this L2VNI vrf (str, optional): protocol="bgp" only -- keep the routers that are a VTEP for this VRF's L3VNI rt (str, optional): protocol="bgp" only -- keep the routers whose resolved RIB view carries this route target page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50) at (str, optional): ISO 8601 moment; state with watcher events applied up to it
Output fields: dict with keys: items: list of nodes with node_id (canonical graph name), display_name (human-readable text), hostname, systemid, networks_count, areas, is_isis, node_attributes (role flags: {"abr":1,"asbr":0,"maxmetric":0} for OSPF, {"overload":1,"attached":0} for IS-IS) pagination: page, per_page, total, total_pages
Equivalent to GET /graph/{graph_time}/nodes.
Inputs: graph_time (required), at, rt, abr, +11 more. Returns: object
get_path_treeARead-onlyIdempotentInspect
The shortest-path tree rooted at one router, equal-cost paths included.
Input fields: graph_time (str): The graph time node (str): Node name, hostname or IS-IS System ID direction (str, optional): "out" for paths from the node (default), "in" for paths to it at (str, optional): ISO 8601 moment; a watcher graph is shown with the events up to it
Output fields: dict with result {root, direction}, nodes and edges (the links of the tree).
Equivalent to GET /graph/{graph_time}/path/{node}.
Inputs: node (required), graph_time (required), at, direction. Returns: object
get_route_eventsARead-onlyIdempotentInspect
Answers "did MAC/IP X move, from where, when": route event history (add/withdraw/MAC-move) of the BGP epochs bound to this graph.
Input fields: graph_time (str): The IGP graph time start_time (str, optional), end_time (str, optional): ISO 8601 window last_minutes (int, optional): Look back this many minutes; overrides start_time/end_time vni (int, optional), vrf (str, optional), rt (str, optional), rd (str, optional), prefix (str, optional), mac (str, optional): same route filters as get_routes page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50)
Output fields: dict: route and peer events interleaved by time; a route row carries moved_from_vtep when it is a MAC's arrival on a new VTEP.
Equivalent to GET /events/{graph_time}/routes.
Inputs: graph_time (required), rd, rt, mac, +8 more. Returns: object
get_routesARead-onlyIdempotentInspect
Answers "where is MAC/IP X", VRF/VNI contents, and hosts behind a leaf: routes of the BGP epochs bound to this graph (the latest of every source), current state by default.
Input fields:
graph_time (str): The IGP graph time, or the name of your OSPF/IS-IS
watcher (Enterprise): the snapshot alive at at (or now) is read and
named in the answer's graph_time
router_id (str, optional): Scope to one router's resolved RIB view;
omit for the whole bound epoch
vni (int, optional): EVPN L2VNI
vrf (str, optional): VRF name, resolved to its RDs across the bound
epoch's own routers
rt (str, optional): Any of the route's route targets
rd (str, optional): Route distinguisher
vtep (str, optional): EVPN originating IP or next-hop
prefix (str, optional): CIDR is an exact match; an address returns
every covering route, longest prefix first
mac (str, optional): EVPN exact match
at (str, optional): Point in time (ISO 8601) instead of current state
page (int): Page number, 1-indexed (default: 1)
per_page (int): Items per page (default: 50)
Output fields: dict with items (route rows, current state carries the winning nexthop) and pagination. An EVPN row's evpn.route_type is the EVPN route type: RT-1 Ethernet A-D, RT-2 MAC/IP, RT-3 IMET, RT-4 Ethernet Segment, RT-5 IP prefix.
Equivalent to GET /graph/{graph_time}/routes or GET /graph/{graph_time}/node/{router_id}/routes.
Inputs: graph_time (required), at, rd, rt, +8 more. Returns: object
get_shortest_pathARead-onlyIdempotentInspect
Calculate the shortest path from one node to one or several destinations.
Description: Plain IGP shortest path by default. For "what if this link is down" backup-path analysis, use get_edge_failure_reaction instead -- that question now has its own endpoint (whole-network impact, not just a recomputed path). Several dst_node values run one SPF from src_node and return a cost/path per target plus the union of every target's edges (MST-style, for colouring several VTEPs' underlay at once); with_lsps takes one destination only.
Input fields: graph_time (str): The graph time src_node (str or list[str]): Source node Router ID (e.g., "10.10.10.1"); a list of sources answers the union of all source-target paths (underlay) dst_node (str or list[str]): One destination Router ID, or several (e.g., ["20.20.20.1", "30.30.30.1"]) with_lsps (bool, optional): If true, account for autoroute-enabled MPLS-TE tunnels as forwarding shortcuts -- the path traffic actually takes given the tunnels currently in the graph, not the plain IGP path. Off by default (a signaled LSP does not redirect traffic on its own without autoroute configured on the tunnel). Keep it off unless the question is about MPLS TE autoroute. One dst_node only; the API rejects it with several. Not with at. failed_edges (list[str], optional): edge_key values from get_edges; the path with these links down (both directions) failed_nodes (list[str], optional): the path with these routers removed changed_edge_costs (dict, optional): edge_key -> new cost of that direction; keyed by edge_key, unlike resolve_route (igraph id) at (str, optional): ISO 8601 moment; state with watcher events applied up to it. Not with a network Routing of the request: - src_node or dst_node containing "/" is an IP or network; a host is given as x.x.x.x/32, since a bare IP is read as an OSPF Router ID - failed_edges, failed_nodes or changed_edge_costs set: backup path, one src and one dst, not with with_lsps - src_node as a list: underlay; not with with_lsps or failures
Output fields: One dst_node: dict with spt_path_nodes_name_as_ll_in_ll (list of node-name paths), cost, unbackup_paths_nodes_name_as_ll_in_ll. Several dst_node: dict with targets (keyed by each destination: cost, spt_path_nodes_name_as_ll_in_ll, unbackup_paths_nodes_name_as_ll_in_ll, or error when unresolved), plus the edges every target's path crosses.
Equivalent to GET /graph/{graph_time}/path/{src_node}/{dst_node}, or with the rules above GET /graph/{graph_time}/path/network, POST /graph/{graph_time}/analyse/spt-edge-failure or POST /graph/{graph_time}/analyse/underlay.
Inputs: dst_node (required), src_node (required), graph_time (required), at, +4 more. Returns: object
get_vrf_inventoryBRead-onlyIdempotentInspect
Router-scoped VRF inventory as of an IGP graph: names, route distinguishers, and per-address-family import/export route targets.
Input fields: graph_time (str): The IGP graph time router_id (str, optional), rd (str, optional): Filters
Output fields: dict with key: items (list of Vrf)
Equivalent to GET /graph/{graph_time}/vrfs.
Inputs: graph_time (required), rd, router_id. Returns: items
list_bgp_bindingsBRead-onlyIdempotentInspect
List the BGP-to-IGP graph bindings known for a BGP graph epoch.
Output fields: dict with key: items (list of BgpBinding)
Equivalent to GET /bgp-graph/{bgp_graph_time}/bindings.
Inputs: bgp_graph_time (required). Returns: items
list_bgp_graphsARead-onlyIdempotentInspect
List BGP graph epochs (one per BMP collection cycle), newest first.
Input fields: page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50)
Equivalent to GET /bgp-graphs.
Inputs: page, per_page. Returns: object
list_bgp_nodesARead-onlyIdempotentInspect
List the BGP speakers of a BGP graph epoch.
Input fields: bgp_graph_time (str): The BGP graph epoch to query role (str, optional): Filter by node role asn (str, optional): Filter by autonomous system number page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50)
Output fields: dict with keys: items (list of BgpNode, each with rib_view, can_build_path, observed_by), pagination
Equivalent to GET /bgp-graph/{bgp_graph_time}/nodes.
Inputs: bgp_graph_time (required), asn, page, role, +1 more. Returns: items, pagination
list_bgp_sessionsARead-onlyIdempotentInspect
List BGP peering sessions of a BGP graph epoch.
Input fields: bgp_graph_time (str): The BGP graph epoch to query igp_relation (str, optional): Filter by relation to the IGP topology (intra-domain, inter-domain, external) bgp_session_type (str, optional): Filter by session type (ibgp, ebgp) page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50)
Output fields: dict with keys: items (list of BgpSession), pagination
Equivalent to GET /bgp-graph/{bgp_graph_time}/sessions.
Inputs: bgp_graph_time (required), page, per_page, igp_relation, +1 more. Returns: items, pagination
list_vpnsARead-onlyIdempotentInspect
Answers "which VNI/VRF exists on which leaf": the fabric-wide VPN/VRF/VNI inventory of the BGP epochs bound to this graph, or one router's own view.
Input fields: graph_time (str): The IGP graph time router_id (str, optional): Scope to one router's resolved RIB view; omit for the fabric-wide list page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 25)
Output fields: VpnsResponse: dict with items (VpnRow: name, route_targets, route_distinguishers, vni, l3vni, prefix_count), pagination, and, router-scoped only, evidence/can_build_path/assumptions.
Equivalent to GET /graph/{graph_time}/vpns or GET /graph/{graph_time}/node/{router_id}/vpns.
Inputs: graph_time (required), page, per_page, router_id. Returns: items, evidence, pagination, assumptions, +1 more
resolve_routeARead-onlyIdempotentInspect
Resolve the path a router would take to a destination, one row per routing decision -- hands off between static/BGP/IGP/LSP whenever one of them overrides the plain SPF path.
Input fields: graph_time (str): The IGP graph to resolve against start_node (str): Router ID the resolution starts from destination (str): Router ID or free-typed prefix rt (str, optional), vrf (str, optional), rd (str, optional): three ways to name one VPN; rt is the only one that identifies it across PEs evidence (str): pre_policy, post_policy, loc_rib (default), or fib -- what the answer rests on when start_node's table is not observed directly with_lsps (bool): Let MPLS TE LSPs override the plain IGP path (default: true) changed_edge_costs (dict, optional): igraph edge id -> new metric, for what-if cost planning
Equivalent to POST /graph/{graph_time}/route-resolution/{start_node}.
Inputs: graph_time (required), start_node (required), destination (required), rd, +5 more. Returns: object
search_bgp_routesARead-onlyIdempotentInspect
Search BGP routes, one row per distinct RFC 4271 9.1 path.
Description: Without router_id, searches the whole BGP graph's route table (GET /routes). With router_id, scopes the search to that speaker's own resolved RIB view (GET /node/{router_id}/routes) -- the routes that speaker actually holds, folded on the same path definition; that scoped form does not accept bmp_source or table_filters (rib_view is already a single table). bmp_source and bmp_ribs come back as arrays.
Input fields: bgp_graph_time (str): The BGP graph epoch to query router_id (str, optional): Scope the search to one speaker's resolved RIB view prefix (str, optional): CIDR is an exact match; an address returns every covering route, longest prefix first vrf (str, optional), rd (str, optional), rt (str, optional): VPN identifiers afi (int, optional), safi (int, optional): Address family filters bmp_rib (str, optional): Filter by RIB tag (e.g. adj-rib-in-pre, loc-rib) evidence (str, optional): pre_policy, post_policy, loc_rib, or fib as_path_contains (str, optional): Substring match over the AS path origin (str, optional), local_pref (int, optional), med (int, optional) community (str, optional), large_community (str, optional), extended_community (str, optional) label (int, optional), originator_id (str, optional), peer_ip (str, optional), nexthop (str, optional) bmp_source (str, optional): Ignored when router_id is set table_filters (str, optional): URL-encoded JSON object keyed by route column, e.g. '{"communities":{"conditions":[{"join":"and","operator":"contains","value":"65000:100"}]}}'. Ignored when router_id is set. ribs (str, optional): Comma-separated exact RIB-tag set to match against the folded policy set, e.g. "loc-rib,post" sort (str, optional): Indexed route column to order by order (str): asc or desc (default: asc) page (int): Page number, 1-indexed (default: 1) per_page (int): Items per page (default: 50)
Equivalent to GET /bgp-graph/{bgp_graph_time}/routes or GET /bgp-graph/{bgp_graph_time}/node/{router_id}/routes.
Inputs: bgp_graph_time (required), rd, rt, afi, +24 more. Returns: items, pagination, sortable_columns
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
Live BGP routing table and registry lookups: IP origin, ASN prefixes, transit, org search.
The internet's infrastructure graph for AI agents - 46B nodes and edges, free trial via 2 HTTP calls
PeeringDB MCP — the peering ecosystem database. Look up networks by name or ASN, find internet…
Cloudflare Radar MCP — internet observatory (traffic, attacks, BGP, quality)
Related MCP Servers
- AlicenseAqualityDmaintenanceVisual network topology editor with AI agent integration via MCP. One-click SSH + web-service access from any node, nmap/CSV import, smart auto-layout, multi-sheet, local-first. Open-source successor to netViz (CA Technologies 1990-2012)4459 npm4MIT

Network Sketcherofficial
AlicenseAqualityBmaintenanceLocal-first MCP server that lets AI agents design Cisco-style networks and generate L1/L2/L3 topology diagrams, device tables, and AI-ready context files.612419Apache 2.0
WhisperGraphofficial
AlicenseAqualityDmaintenanceSelf-hostable MCP server for WhisperGraph — a graph of 7.39B nodes / 39B edges mapping DNS, BGP, GeoIP, WHOIS, and threat intelligence. Six read-only tools (Cypher query + schema introspection + threat assessment), six resources, eight investigation prompts. stdio and Streamable HTTP transports.862 npm1Apache 2.0- AlicenseNot gradedqualityCmaintenanceEnables AI-assisted management of multi-vendor network devices (Cisco, Juniper, Nokia, Arista, Linux) through natural language, supporting health checks, configuration changes, routing analysis, and automation workflows.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.