Skip to main content
Glama

Elite Dangerous MCP service (ed-mcp)

Ask an LLM plain-English questions about Elite Dangerous and get answers grounded in your local journal files plus public galaxy data from the EDDN (Elite Dangerous Data Network), EDSM, Spansh, and Inara.

Example queries this server is built to answer:

  • "Find all stars within 15 light years of the stars in the Teapot (Sagittarius) asterism that have zero population and are claimable for a brand-new space station."

  • "Make a shopping list to set up my Anaconda as a maximum-cargo hauler: use my journal to find my current system, then find which nearby stations sell the modules I need, where to get them, and how much they cost."

How it works

Claude / LLM client  <--MCP (stdio)-->  ed-mcp server
                                            |-- local journals  (%USERPROFILE%\Saved Games\...)
                                            |-- EDSM API        (systems, sphere, stations)
                                            |-- Spansh API      (systems/stations search, trade)
                                            |-- Inara API       (needs INARA_API_KEY)
                                            |-- EDDN relay      (live ZeroMQ firehose docs + sampler)

MCP tools

Tool

Source

What it does

get_commander_status

journal

Commander name, current system/station, ship, credits, rank summary

get_current_location

journal

Current system + coordinates, station, body — always from latest journal

get_ship_loadout

journal

Current ship type + modules from latest Loadout event

get_journal_history

journal

Last N relevant events (FSDJump, Docked, Location, Outfitting, …)

get_cargo_hold

journal

Cargo manifest + rack capacity + free space (Cargo.json + Loadout)

get_station_market

journal

Live market at docked station (prices/supply/demand from Market.json)

get_station_outfitting

journal

Outfitting stock at station (Outfitting.json + ModulesInfo.json)

get_station_shipyard

journal

Shipyard stock at station (Shipyard.json)

get_fleet_overview

journal

All ships + computed cargo each (latest first)

find_stored_ship

journal

Locate a stored ship: station/system + transfer cost/time

get_wallet_summary

journal

Credits + trade/mission reward sums

get_odyssey_state

journal

Backpack + ShipLocker + suit loadout (on-foot)

edsm_sphere_systems

EDSM

Systems in a radius around coordinates / system name

edsm_system_info

EDSM

Population, government, allegiance, bodies for a system (claimable check)

spansh_find_nearby_stations

Spansh

Stations near coordinates with pads, distance, services

spansh_query_systems

Spansh

Flexible tradedangerous-style systems search near a reference

spansh_search_stations

Spansh

Full /stations/search passthrough (pads/services/market filters)

find_commodity

Spansh

Best buy/sell stations for a commodity near you (supply/demand + prices)

find_multi_supply

Spansh

One station covering a whole shopping list (minimum supply each; orbital/large-pad filters)

find_module

Spansh

Stations selling a module near you (multi-page scan; acquisition flags: credits vs special pre-engineered/tech-broker/Powerplay)

find_ship

Spansh

Stations selling a ship near you (multi-page scan; price_note re verify in-game)

get_ship_purchase_history

journal

Your actual ship purchase history (ShipyardBuy/Sell/Swap) with real prices

get_module_purchase_history

journal

Your module purchase history (ModuleBuy/Sell/Retrieve) with real prices

get_stored_modules

journal

Your stored modules per station — transfer instead of buying (find_module also checks storage automatically)

station_services

Spansh

Services/pads/market for a named station (disambiguate by full system name; flags Colonisation contact)

spansh_search_bodies

Spansh

Exploration search over bodies (Earth-likes, values, landables)

system_distance

EDSM

LY distance + jump estimate between two systems

find_local_opportunities

EDSM

Trade hubs + mission ports + exobio frontier near you

get_exobiology_samples

journal+EDSM

Exobiology status: FSS complete, organic scans, DSS mapped, community-discovered, estimated turn-in credits

find_exobiology_targets

Spansh

Organic-rich body search near you + per-system turn-in credit ranking

inara_search_nearest

Inara

Nearest stations/components via Inara API (needs key)

inara_website_search

Inara web

Search links + page check, no key (bot-limited, open in browser)

eddn_live_sample

EDDN

Sample N live EDDN messages from the relay (commodity/outfitting/shipyard)

find_colonisation_candidates

EDSM+local

Zero-pop, claimable systems near a constellation/centre (Teapot example)

get_colony_progress

journal

Colony scoreboard: manifest + delivered/remaining/% + your pace + ETA

get_exploration_log

journal

Per-system survey ledger (COMPLETE/PARTIAL/VISITED) + totals

system_scan_status

EDSM+journal

Community bodies catalog + value for one system, plus your log row

find_search_backlog

EDSM+journal

Systems near a reference you have not fully scanned (search backlog)

build_cargo_shopping_list

journal+Spansh/EDSM

Anaconda max-cargo module list + where to buy near you + prices

Three MCP prompts (colonisation_survey, anaconda_cargo_refit, trade_run, raxxla_survey) encode the worked examples above so the LLM follows a grounded workflow instead of guessing.

Related MCP server: eve-fit

Quickstart

Requires Python 3.10+.

# 1. Clone
git clone https://github.com/ramgarden/ed-mcp.git
Set-Location ed-mcp

# 2. Install (venv recommended)
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -e ".[dev]"

# 3. Configure (optional but recommended for Inara tools)
Copy-Item .env.example .env
# edit .env -> INARA_API_KEY=...

# 4. Run tests
pytest -q

# 5. Run the MCP server (stdio)
python -m ed_mcp.server

Claude Desktop config

{
  "mcpServers": {
    "ed-mcp": {
      "command": "C:\\Users\\YOU\\Source\\ed-mcp\\.venv\\Scripts\\python.exe",
      "args": ["-m", "ed_mcp.server"],
      "env": { "INARA_API_KEY": "…" }
    }
  }
}

For Claude Code / mcp add, any stdio MCP client works — point it at python -m ed_mcp.server.

OpenCode config

Add an ed-mcp entry under mcpServers in your OpenCode config (%USERPROFILE%\.config\opencode\opencode.json on Windows, ~/.config/opencode/opencode.json on macOS/Linux):

{
  "mcpServers": {
    "ed-mcp": {
      "command": "C:\\Users\\YOU\\Source\\ed-mcp\\.venv\\Scripts\\python.exe",
      "args": ["-m", "ed_mcp.server"],
      "env": { "INARA_API_KEY": "…" }
    }
  }
}

Notes:

  • Use the venv Python from step 2 above (the package is installed editable, so -m ed_mcp.server resolves from any working directory).

  • env is optional — without INARA_API_KEY only the inara_* API tools stay dormant; the inara_website_search fallback still works.

  • Restart OpenCode (or opencode mcp reload if supported) after editing.

GitHub Copilot (VS Code) config

Copilot agent mode consumes MCP servers declared in a workspace .vscode/mcp.json file (requires VS Code with MCP support enabled). Create .vscode/mcp.json in your workspace:

{
  "servers": {
    "ed-mcp": {
      "type": "stdio",
      "command": "C:\\Users\\YOU\\Source\\ed-mcp\\.venv\\Scripts\\python.exe",
      "args": ["-m", "ed_mcp.server"],
      "env": { "INARA_API_KEY": "…" }
    }
  }
}

Notes:

  • On macOS/Linux use the venv binary path instead, e.g. /home/YOU/Source/ed-mcp/.venv/bin/python.

  • After saving, run MCP: List Servers from the VS Code command palette to confirm ed-mcp starts, then approve its tools when Copilot asks — approval is per session.

  • Same INARA_API_KEY note as above: optional, only gates inara_* API tools.

Journal location

Defaults (in order):

  1. ED_JOURNAL_DIR env var

  2. %USERPROFILE%\Saved Games\Frontier Developments\Elite Dangerous

  3. ~/.local/share/Frontier Developments/Elite Dangerous (Proton/Linux)

If no journals are found the journal tools return a clear {"found": false, …} payload so the LLM can ask the user for a path instead of hallucinating.

Data sources & credits

This is a community tool. Not affiliated with Frontier Developments, EDDN/EDCD, EDSM, Spansh, or Inara.

Available Tools

58 tools
aggregate_temporal_eventsB

Aggregate timestamped EDDN/journal events into a time series.

Returns intervals with event-type counts. Systems without timestamps are skipped (not silently converted to zero).

Inputs: events (required), event_types, system_name, interval_minutes. Returns: object

analyze_graph_metricsC

Build a graph and compute structural metrics in one call.

Returns: connected components, degree distribution, bridges, articulation points, betweenness centrality, and motif counts.

Inputs: x, y, z, radius_ly, +3 more. Returns: object

analyze_spatial_geometryC

Analyze geometric structure of systems in a bounded EDSM sphere.

Computes linearity, planarity, spread, centroid, compactness, and nearest-neighbor statistics to identify linear arrangements, planar structures, or spherical clusters.

Inputs: x, y, z, radius_ly, +1 more. Returns: object

build_cargo_shopping_listC

Anaconda max-cargo module list + where to buy near your current location.

Uses journals for current system/coords + owned modules, Spansh for nearby stations with outfitting, EDSM sphere as fallback. Prices/stock rotate; verify at the station.

Inputs: journal_dir, max_stations, search_radius_ly. Returns: object

build_system_graphB

Build a jump-range proximity graph for a bounded EDSM sphere.

Queries EDSM for systems within radius_ly, then constructs edges between all pairs within max_edge_distance. Returns graph snapshot with nodes, edges, and metadata. Missing coordinates are preserved as isolated nodes with explicit missing flags.

Inputs: x, y, z, radius_ly, +3 more. Returns: object

check_temporal_persistenceC

Check persistence of anomalous patterns across two time windows.

Returns per-event-type persistence flags with relative proportion change.

Inputs: series1 (required), series2 (required), interval (required), min_overlap. Returns: object

complete_experimentB

Mark an experiment run as complete with results or error.

Records completion time, result summary, and any error message. The agent should have gathered results from approved MCP tools before calling this.

Inputs: run_id (required), error_message, result_summary. Returns: object

create_experimentB

Define a bounded scientific experiment with provenance tracking.

Creates an experiment definition that can be tracked with runs, results, and controls. Parameters and control design should be minimal and deterministic.

Inputs: title (required), method (required), hypothesis (required), parameters, +1 more. Returns: object

detect_change_pointsB

Detect change points using sliding window mean comparison.

Compares early vs late window means; flags changes exceeding sensitivity * MAD. Works on per-event-type time series.

Inputs: series (required), interval (required), sensitivity, window_size. Returns: object

detect_temporal_outliersC

Robust outlier detection on event counts for a given interval.

Methods: 'IQR' (interquartile range) or 'zscore' (standard deviations). Returns per-event-type outlier flags and statistics.

Inputs: series (required), interval (required), method, z_threshold. Returns: object

eddn_live_sampleB

Bounded sample of live EDDN relay messages (needs pyzmq + network).

schema: substring filter on $schemaRef, e.g. "commodity". None = all.

Inputs: schema, timeout_s, max_messages. Returns: object

edsm_sphere_systemsC

Systems within radius_ly of a system name or x/y/z coords (EDSM).

Inputs: x, y, z, radius_ly, +1 more. Returns: object

edsm_system_infoC

Population/government/stations for one system + claimable assessment (EDSM).

Inputs: system_name (required). Returns: object

find_colonisation_candidatesB

Zero-pop, claimable systems near a constellation/centre.

centre: 'teapot' (Sagittarius asterism) or an EDSM system name or 'x,y,z'. Workflow: resolve Teapot anchor stars -> EDSM sphere search per anchor -> batch detail lookup -> filter zero-pop/uncontrolled/stationless -> dedupe.

Inputs: centre, radius_ly, max_candidates. Returns: object

find_commodityB

Best stations trading a commodity near you (live Spansh market snapshots).

mode 'buy' = station has supply; 'sell' = station has demand. Sorted by stock size then distance. Stock rotates; verify in-game before flying.

Inputs: commodity (required), x, y, z, +6 more. Returns: object

find_exobiology_targetsB

Best exobiology targets near you: organic-rich systems with estimated turn-in.

Uses Spansh bodies search for organic-life bodies, ranks systems by estimated turn-in credits (body value x biology multiplier). Returns per-system body breakdown with distance and estimated value.

Inputs: x, y, z, radius_ly, +3 more. Returns: object

find_local_opportunitiesA

What's profitable near you: trade hubs, mission ports, exobio frontier.

Live EDSM sphere around a system (or your journal location) grouped into money-making buckets. Buckets only — follow up with find_commodity or station_services before flying.

Inputs: radius_ly, journal_dir, system_name. Returns: object

find_moduleB

Stations selling a module near you (matches name or ed_symbol, live Spansh).

Scans pages x 100 nearest stations (default 1, max 10): Spansh outfitting snapshots are sparse, so one page misses stock. Each hit carries acquisition ("credits" vs "special") — pre-engineered/tech-broker/ Powerplay stock (e.g. mercgear) is NOT a plain credit purchase. standard_only=True drops special-acquisition hits.

Inputs: module_query (required), x, y, z, +5 more. Returns: object

find_multi_supplyA

One station covering a whole shopping list (live Spansh markets).

commodities maps name -> minimum supply for one full load, e.g. {"Steel": 2000, "Titanium": 2000}. Scans pages x 100 nearest stations (default 4, max 10); full-cover stations first, then most lines covered, then nearest. Stock rotates; verify in-game before flying.

Inputs: commodities (required), x, y, z, +6 more. Returns: object

find_search_backlogB

Systems near a reference YOU have not fully scanned (Raxxla grid backlog).

Cross-references live EDSM sphere (with bodyCount) against your journal ledger: UNVISITED first, then VISITED-but-incomplete. Confirm in-game.

Inputs: system_name (required), radius_ly, journal_dir, max_results. Returns: object

find_shipB

Stations selling a ship near you (live Spansh shipyard lists).

Scans pages x 100 nearest stations (default 4, max 10): Spansh shipyard snapshots are sparse, so one page misses stock. Each hit carries a price_note reminding you to verify the price in-game — ship discounts are time-limited and not exposed in Spansh public snapshots.

Inputs: ship_query (required), x, y, z, +4 more. Returns: object

find_spatial_clustersB

Find DBSCAN spatial clusters in a bounded EDSM sphere.

Queries EDSM for systems within radius_ly, extracts coordinates, then runs DBSCAN with eps_ly and min_samples. Returns clusters, noise points, and per-point assignments. Systems without coordinates are excluded from clustering but noted.

Inputs: x, y, z, eps_ly, +3 more. Returns: object

find_stored_shipA

Locate a stored ship: station/system + transfer cost/time.

Matches name or ship type (case-insensitive); omit query to list all. Latest StoredShips sighting per ship wins.

Inputs: query, journal_dir. Returns: object

get_cargo_holdC

Current cargo manifest + rack capacity + free space (Cargo.json + Loadout).

Inputs: journal_dir. Returns: object

get_colony_progressA

Colony build scoreboard from your journals (latest depot manifest).

Per-commodity required/provided/remaining plus totals, overall progress, claimed system, your-vs-others tonnage, delivery pace and ETA vs the 28-day window. Returns found False when no claim/beacon exists yet.

Inputs: journal_dir. Returns: object

get_commander_statusC

Commander name, current system/station, ship, credits from local journals.

Inputs: journal_dir. Returns: object

get_current_locationB

Current system + coords + station from latest Location/FSDJump/Docked event.

Inputs: journal_dir. Returns: object

get_exobiology_samplesB

Exobiology sample status: discovery, FSS progress, estimated turn-in credits.

Reads local journals for FSSAllBodiesFound / ScanOrganic / SAAScanComplete events. When FSS complete, uses EDSM estimated system value for turn-in credits. community_discovered=True means FSS complete OR EDSM has catalogued bodies (others discovered before you).

Inputs: journal_dir, system_name. Returns: object

get_experiment_resultB

Retrieve a completed experiment run's results with full provenance.

Returns the stored run with result summary, provenance observations, and metadata.

Inputs: run_id (required). Returns: object

get_exploration_logB

Per-system survey ledger from YOUR journals (COMPLETE/PARTIAL/VISITED).

grade: optionally filter to one grade. limit caps rows (default 50).

Inputs: grade, limit, journal_dir. Returns: object

get_fleet_overviewB

Every ship in your journals + computed cargo per ship (latest first).

Inputs: journal_dir. Returns: object

get_journal_historyC

Recent relevant journal events, newest first (FSDJump, Docked, Loadout, ...).

Inputs: limit, journal_dir. Returns: object

get_module_purchase_historyB

Your module purchase history from journal events (ModuleBuy/ModuleSell/ModuleRetrieve).

Returns real purchase prices, stations, systems, timestamps — useful for comparing current outfitting prices vs what you actually paid.

Inputs: journal_dir, module_query. Returns: object

get_odyssey_stateC

On-foot state: Backpack + ShipLocker + latest suit loadout events.

Inputs: journal_dir. Returns: object

get_ship_loadoutB

Current ship + modules from latest Loadout event.

Inputs: journal_dir. Returns: object

get_ship_purchase_historyB

Your actual ship purchase history from journal events (ShipyardBuy/ShipyardSell).

Returns real purchase prices, stations, systems, timestamps — useful for comparing current market prices vs what you actually paid, spotting discounts.

Inputs: ship_query, journal_dir. Returns: object

get_station_marketB

Live market at your docked station (Market.json): prices/supply/demand.

Inputs: journal_dir. Returns: object

get_station_outfittingC

Outfitting stock at your station (Outfitting.json + ModulesInfo.json).

Inputs: journal_dir. Returns: object

get_station_shipyardC

Shipyard stock at your station (Shipyard.json).

Inputs: journal_dir. Returns: object

get_stored_modulesA

Modules you own in storage, per station (StoredModules journal events).

Check here before buying: a stored module only needs a transfer. Open outfitting/storage in-game to refresh a station's entry.

Inputs: journal_dir. Returns: object

get_wallet_summaryC

Credits now + lifetime MarketBuy/MarketSell/MissionCompleted sums.

Inputs: journal_dir. Returns: object

graph_sensitivity_analysisC

Run graph construction across multiple jump-range radii.

Returns per-radius metrics for parameter sensitivity testing.

Inputs: x, y, z, radii, +3 more. Returns: object

inara_search_nearestC

Nearest stations/systems via Inara API (needs INARA_API_KEY + app access).

Falls back to website search URLs when the API app has no access.

Inputs: system_name (required), search, commander. Returns: object

list_experiment_runsB

List all runs for an experiment (or all experiments).

Returns run summaries ordered by start time descending.

Inputs: experiment_id. Returns: object

list_observationsB

List provenance-tracked observations with filtering.

Filters by source and/or system name. Never silently converts missing values; all observations retain their missing/observed status.

Inputs: limit, source, system_name. Returns: object

normalize_temporal_activityB

Normalize activity counts by accessibility/traffic indicators.

Methods: 'traffic_normalized', 'population_normalized', 'raw'. Returns normalized series with caveats for missing data.

Inputs: series (required), method, accessibility_data. Returns: object

query_bounded_regionB

Query a bounded EDSM sphere region with full provenance tracking.

Caps results at 200 systems to keep responses bounded. Systems missing coordinates are explicitly marked rather than silently dropped. Returns region metadata, system list with provenance, and any errors.

Inputs: x, y, z, radius_ly, +1 more. Returns: object

run_experimentB

Create a new run of a bounded scientific experiment.

Records the run start time, software version, model/provider metadata if applicable, and optional random seed. The agent should invoke approved MCP tools to populate results, then call complete_experiment.

Inputs: experiment_id (required), random_seed, bounded_inputs. Returns: object

save_observationC

Save a provenance-tracked source observation to the research store.

All missing data is explicitly marked rather than silently converted. Returns the observation ID and provenance summary.

Inputs: source (required), data_type, coordinates, raw_payload, +7 more. Returns: object

spansh_find_nearby_stationsC

Stations nearest to galactic coords, slimmed for shopping lists (Spansh).

Inputs: x (required), y (required), z (required), max_results. Returns: object

spansh_query_systemsC

Flexible Spansh systems search, e.g. {"population": {"value": [0,0]}}.

Inputs: page, filters. Returns: object

spansh_search_bodiesC

Exploration search over Spansh bodies (e.g. Earth-likes near a reference).

Inputs: x, y, z, page, +3 more. Returns: object

spansh_search_stationsC

Full Spansh /stations/search passthrough (pads/services/market filters).

Inputs: x, y, z, page, +3 more. Returns: object

spatial_sensitivity_analysisB

Run DBSCAN across parameter combinations for sensitivity testing.

Returns per-parameter-set cluster counts, noise counts, and cluster details to assess robustness of spatial patterns.

Inputs: x, y, z, radius_ly, +3 more. Returns: object

station_servicesA

Services/pads/market for a named station (live Spansh).

Duplicate station names exist across systems: pass system_name (full name) to disambiguate, otherwise all matches are returned. Flags the System Colonisation contact explicitly. Stock snapshots rotate; verify in-game before flying.

Inputs: station_name (required), system_name. Returns: object

system_distanceB

Light-year distance between two systems (live EDSM coords) + jump estimate.

Inputs: to_system (required), from_system (required), jump_range_ly. Returns: object

system_scan_statusB

How deeply has ONE system been scanned — community catalog + your log.

Community: live EDSM bodies catalog count + type break-down + scan value. You: matching journal row (visits/FSS/scans/mapped) if ever visited.

Inputs: system_name (required), journal_dir. Returns: object

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    C2.7/5.0

    Scored across 58 tools

    Disambiguation3/5

    The 58 tools span many distinct domains, but several station-search and analytics tools overlap in purpose, e.g. find_ship/find_module/find_commodity vs spansh_search_stations/station_services, and analyze_graph_metrics vs graph_sensitivity_analysis. Descriptions help distinguish them, but the sheer number and similar patterns create real misselection risk.

    Naming Consistency3/5

    All names use snake_case and are readable, but the convention is mixed: verb-first names (get_, find_, build_, analyze_, create_, list_) coexist with source-prefixed names (spansh_, edsm_, inara_, eddn_) and noun-only names such as system_distance and station_services. There is no single predictable pattern throughout.

    Tool Count1/5

    At 58 tools, the server is far beyond a well-scoped 3–15 tool set and exceeds the 25+ threshold where sprawl becomes a usability problem. Many tools are specialized analytics or data-source variants, making the surface feel like multiple MCP servers combined into one.

    Completeness4/5

    Coverage is broad across journal state, trade/outfitting, exploration, exobiology, colonisation, and research analytics. There are still notable gaps for a full Elite Dangerous assistant, such as missions, engineering/blueprints, combat, powerplay, and deleting/updating research records, but core data workflows are well represented.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      This MCP server provides real-time integration between Elite Dangerous and Claude Desktop, enabling AI-powered analysis of your gameplay data and dynamic generation of EDCoPilot custom content.
      3
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to search EVE Online items, validate ship fits against fitting limits, compute combat stats like DPS and EHP, and retrieve Jita market prices.
      4
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI clients to access live Elite Dangerous game context such as location, route, ship loadout, and journal history through local MCP tools, with an optional GitHub relay for remote access.
      1
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables AI assistants to discover and invoke read-only EVE Online ESI API endpoints, retrieve public and character data with automatic OAuth, and turn that context into practical adventure plans.
      3
      48 npm
      2
      AGPL 3.0