Elite Dangerous MCP
You can use this server to ground LLM answers in local Elite Dangerous journals and public galaxy APIs for commander, ship, trade, exploration, colonisation, exobiology, and research/analytics workflows.
Read local journals for commander status, current location, ship loadout, cargo, station market/outfitting/shipyard, fleet, wallet, Odyssey state, purchase history, stored ships/modules, colony progress, and exploration logs.
Query EDSM, Spansh, and Inara for systems, stations, commodities, modules, ships, bodies, distances, local opportunities, exobiology targets, colonisation candidates, and scan backlog.
Sample live EDDN relay messages.
Build cargo shopping lists and support Anaconda refits, trade runs, colonisation surveys, and exobiology workflows.
Track bounded scientific experiments with runs, results, observations, and provenance.
Query bounded EDSM regions and build/analyze jump-range graphs, graph metrics, spatial clusters, spatial geometry, and sensitivity analyses.
Aggregate temporal events and detect outliers, change points, normalise activity, and check temporal persistence.
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., "@Elite Dangerous MCP What's my current location and ship loadout?"
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.
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 |
| journal | Commander name, current system/station, ship, credits, rank summary |
| journal | Current system + coordinates, station, body — always from latest journal |
| journal | Current ship type + modules from latest |
| journal | Last N relevant events ( |
| journal | Cargo manifest + rack capacity + free space ( |
| journal | Live market at docked station (prices/supply/demand from |
| journal | Outfitting stock at station ( |
| journal | Shipyard stock at station ( |
| journal | All ships + computed cargo each (latest first) |
| journal | Locate a stored ship: station/system + transfer cost/time |
| journal | Credits + trade/mission reward sums |
| journal | Backpack + ShipLocker + suit loadout (on-foot) |
| EDSM | Systems in a radius around coordinates / system name |
| EDSM | Population, government, allegiance, bodies for a system (claimable check) |
| Spansh | Stations near coordinates with pads, distance, services |
| Spansh | Flexible tradedangerous-style systems search near a reference |
| Spansh | Full |
| Spansh | Best buy/sell stations for a commodity near you (supply/demand + prices) |
| Spansh | One station covering a whole shopping list (minimum supply each; orbital/large-pad filters) |
| Spansh | Stations selling a module near you (multi-page scan; acquisition flags: credits vs special pre-engineered/tech-broker/Powerplay) |
| Spansh | Stations selling a ship near you (multi-page scan; price_note re verify in-game) |
| journal | Your actual ship purchase history (ShipyardBuy/Sell/Swap) with real prices |
| journal | Your module purchase history (ModuleBuy/Sell/Retrieve) with real prices |
| journal | Your stored modules per station — transfer instead of buying ( |
| Spansh | Services/pads/market for a named station (disambiguate by full system name; flags Colonisation contact) |
| Spansh | Exploration search over bodies (Earth-likes, values, landables) |
| EDSM | LY distance + jump estimate between two systems |
| EDSM | Trade hubs + mission ports + exobio frontier near you |
| journal+EDSM | Exobiology status: FSS complete, organic scans, DSS mapped, community-discovered, estimated turn-in credits |
| Spansh | Organic-rich body search near you + per-system turn-in credit ranking |
| Inara | Nearest stations/components via Inara API (needs key) |
| Inara web | Search links + page check, no key (bot-limited, open in browser) |
| EDDN | Sample N live EDDN messages from the relay (commodity/outfitting/shipyard) |
| EDSM+local | Zero-pop, claimable systems near a constellation/centre (Teapot example) |
| journal | Colony scoreboard: manifest + delivered/remaining/% + your pace + ETA |
| journal | Per-system survey ledger (COMPLETE/PARTIAL/VISITED) + totals |
| EDSM+journal | Community bodies catalog + value for one system, plus your log row |
| EDSM+journal | Systems near a reference you have not fully scanned (search backlog) |
| 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.serverClaude 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.serverresolves from any working directory).envis optional — withoutINARA_API_KEYonly theinara_*API tools stay dormant; theinara_website_searchfallback still works.Restart OpenCode (or
opencode mcp reloadif 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-mcpstarts, then approve its tools when Copilot asks — approval is per session.Same
INARA_API_KEYnote as above: optional, only gatesinara_*API tools.
Journal location
Defaults (in order):
ED_JOURNAL_DIRenv var%USERPROFILE%\Saved Games\Frontier Developments\Elite Dangerous~/.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
EDDN relay
tcp://eddn.edcd.io:9500(ZeroMQ) — message docs: https://github.com/EDCD/EDDNEDSM API — https://www.edsm.net/en/api-v1
Spansh API — https://spansh.co.uk/api
Inara API — https://inara.cz/settings-api/ (key required)
Journal spec — https://elite-journal.readthedocs.io/
This is a community tool. Not affiliated with Frontier Developments, EDDN/EDCD, EDSM, Spansh, or Inara.
Available Tools
58 toolsaggregate_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
inara_website_searchC
Inara website search links + page check (no API key needed).
Inputs: commodity, system_name, station_name. 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
Scored across 58 tools
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.
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.
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.
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
Related MCP Connectors
Ingest and search LogsLoom logs from coding agents.
Persistent memory and knowledge management for AI agents with semantic search and 50+ tools.
Certified SEC EDGAR fact memory for AI agents with zero hallucination and filing provenance.
Astra DB tools for agents: schema, find, vector search, guarded writes, and interactive views.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceThis 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.3MIT
- AlicenseAqualityDmaintenanceEnables 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.4MIT
- AlicenseNot gradedqualityBmaintenanceEnables 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.1MIT
- AlicenseAqualityBmaintenanceEnables 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.348 npm2AGPL 3.0