astrodynamics-mcp

Astrodynamics MCP server: TLE/SGP4, Lambert, access windows, porkchop, B-plane targeting.

Connector by astro-tools · GitHub account verified by the MCP Registry

IndexedMITLocal (stdio)★ 2

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/astro-tools-astrodynamics-mcp

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

About

Astrodynamics MCP server: TLE/SGP4, Lambert, access windows, porkchop, B-plane targeting.

Reviews

Write a review

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Tools: 23 read · 0 write · 2 delete
Secrets: None asked for
Install scripts: Not scanned yet
Runs as: Python package

Tools by what they do 25

Read from the source code; the running server may list different tools.

Read 23 · Look things up without changing anything.

access_windows
bplane_target
czml_trajectory
frame_transform
gmat_execute_script
gmat_read_run_artefact
gmat_run_mission
gmat_sweep
gmat_validate_script
lambert_solve
plot_ground_track
plot_porkchop

Show 11 more tools

plot_trajectory
porkchop
satellite_metadata
sgp4_propagate
spice_body_parameters
spice_frame_transform
spice_list_kernels
spice_state
spice_time_convert
time_convert
tle_lookup

Delete 2 · Delete, drop, revoke or wipe things.

spice_load_kernel
spice_unload_kernel

Files it touches

Any path the agent passes to its tools

Tools (25)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

access_windowsGround-Station Access Windowsread-only
Compute ground-station / observer access intervals for a TLE-defined satellite over a UTC time window. e.g. access_windows(observer={'name': 'madrid'}, target_tle={'line1': '...', 'line2': '...'}, start='2024-01-01T00:00:00Z', end='2024-01-02T00:00:00Z', min_elevation_deg=10) returns the satellite's passes above 10° as seen from Madrid. `observer` is either a named-station dict ({'name': 'madrid' | 'goldstone' | 'canberra' | 'svalbard' | 'wallops' | 'esrange' | 'gsfc' | 'jpl'}) or explicit geodetic coordinates ({lat, lon, alt}). Epochs are UTC ISO 8601 with a mandatory time component ('2024-01…
bplane_targetB-Plane Targetingread-only
Compute B-plane coordinates (B·T, B·R), hyperbolic excess velocity v_∞, and asymptote declination for a hyperbolic planetocentric flyby, and optionally return the linearised one-step Δv at the input epoch that drives the B-plane to caller-supplied target coordinates. e.g. bplane_target(state={'r': {'value': [5000, 0, 0], 'unit': 'km'}, 'v': {'value': [0, 5.069, 0], 'unit': 'km/s'}, 'frame': 'ICRF', 'epoch': '2026-12-01T00:00:00Z'}, target_body='mars', target_epoch='2026-12-01T00:00:00Z', target_btr_km=1000.0) returns the current B-plane state plus the Δv that drives B·R toward 1000 km. Read-on…
czml_trajectoryCZML Trajectoryread-only
Convert a trajectory into a CZML document for a Cesium 3D client and return it as an embedded resource, with an inline summary (packet count, time span). e.g. czml_trajectory(trajectory=<sgp4_propagate output series>) renders an animated orbit. Pass the whole state SERIES (each entry a {r, v, frame, epoch}); velocity is optional — a position-only series is rendered with the velocity NaN-padded. All states must share one CZML-renderable frame (TEME, ICRF, GCRS, ITRS). COMMON MISTAKES: the output is a CZML document for a Cesium client — NOT an image, and not every client renders it; and 'traject…
frame_transformCoordinate-Frame Transformread-only
Transform a Cartesian state vector from its current frame into a different reference frame. e.g. frame_transform(state={r: ..., v: ..., frame: 'TEME', epoch: '2024-01-01T12:00:00Z'}, to_frame='ICRF') re-expresses the state in ICRF. Supported frames: ICRF (barycentric inertial), GCRS (Earth-centred inertial), ITRS (Earth-fixed rotating), TEME (SGP4's native output), CIRS (Earth-rotating intermediate), IAU_EARTH (alias for ITRS — same Earth-body-fixed frame, different naming). The `epoch` arg defaults to the state's own epoch; pass an override only when you deliberately want to transform 'as if …
gmat_execute_scriptGMAT Execute Scriptread-only
Escape-hatch raw GMAT script executor — minimal validation, raw text output. Prefer gmat_run_mission whenever your goal is 'run this mission and tell me what happened': it returns a structured snapshot, parsed report rows, and typed convergence flags, all shape-disciplined for small-model contexts. Reach for gmat_execute_script only when the curated surface doesn't fit — e.g. you need the raw ReportFile text verbatim (header line, units row, formatting) instead of parsed rows, or you want to run a script with side-effect-only commands that don't surface through the structured response. e.g. gm…
gmat_read_run_artefactGMAT Read Run Artefactread-only
Read the raw text of one file written by a prior gmat_run_mission, gmat_sweep, or gmat_execute_script call, keyed by the `run_id` that producer returned. The producer tools shape their inline responses for small-model input caps; reach for this tool when you need the verbatim bytes of an output that was too large to inline (a long EphemerisFile, a ContactLocator report, the GMAT log) or when you want a ReportFile's header / units rows preserved exactly. e.g. after gmat_run_mission returns run_id='abc...' with an OutputPointer for 'EphemerisFile1', call gmat_read_run_artefact(run_id='abc...', n…
gmat_run_missionGMAT Run Missionread-only
Run a single GMAT mission script end-to-end and return structured results (report tables, ephemeris pointers, convergence flags). e.g. gmat_run_mission(script='/abs/path/to/Ex_HohmannTransfer.script') runs a stock GMAT Hohmann transfer sample and returns the ReportFile data inline plus the DifferentialCorrector's converged flag. `script` must be either an absolute path to a .script file or the full inline script text (auto-detected by leading '%' / 'Create' markers); do not pass a Python Mission object. `overrides` apply dotted-path field writes (e.g. {'Sat.SMA': 7000.0}) using the same gramma…
gmat_sweepGMAT Parameter Sweepread-only
Run a parameter sweep, explicit-sample replay, Monte Carlo, or Latin hypercube over a GMAT mission script via the gmat-sweep backend. `mode` selects which family runs and which payload fields are read. e.g. gmat_sweep(script='/abs/path/to/hohmann.script', mode='grid', grid={'Sat.SMA': [7000, 7100, 7200], 'Sat.INC': [28.5, 51.6]}) runs a 6-point full factorial; gmat_sweep(script=..., mode='samples', samples=[{'Sat.SMA': 7000, 'Sat.INC': 28.5}, {'Sat.SMA': 7100, 'Sat.INC': 51.6}]) runs one mission per explicit row; gmat_sweep(script=..., mode='monte_carlo', perturb={'Sat.SMA': ['normal', 7000, 5…
gmat_validate_scriptGMAT Validate Scriptread-only
Parse-validate a GMAT mission script without running the mission sequence: load it through GMAT's interpreter, capture any errors and warnings GMAT itself surfaces, and return them alongside the parsed resource and command inventory. Intended for a self-correction loop where an LLM iterates on its script — call gmat_validate_script, fix what GMAT flags, then call gmat_run_mission. e.g. gmat_validate_script(script='/abs/path/to/Ex_HohmannTransfer.script') returns ok=True with a summary listing the declared Spacecraft, ForceModel, Propagator, ReportFile resources and the mission-sequence command…
lambert_solveLambert Solverread-only
Solve Lambert's problem — find the orbital transfer between two position vectors r1 and r2 in a given time-of-flight tof. e.g. lambert_solve(r1=[5000, 10000, 2100], r2=[-14600, 2500, 7000], tof=3600, mu='earth') returns the initial and final inertial velocities on the transfer arc plus the arc's classical orbital elements. `mu` selects the central body and is REQUIRED — there is no default, because the wrong choice silently produces garbage. `r1` and `r2` are heliocentric km when mu='sun'; geocentric km when mu='earth'; planetocentric km for other named bodies. If your problem is interplanetar…
plot_ground_trackPlot Ground Trackread-only
Render a satellite's sub-satellite ground track as a PNG over a lon/lat graticule, with an inline summary (revolutions, lat / lon extent) carried alongside the image. e.g. plot_ground_track(states=<sgp4_propagate output series>) for a 24-hour ISS track. Pass the whole state SERIES, not a single state — the track needs many epochs to trace. States may be in any Earth frame (TEME, ICRF, GCRS, CIRS, ITRS); inertial frames are rotated to Earth-fixed internally, so for the cheapest path propagate with frame='ITRS'. The PNG is additive — the numeric summary is always inline, so a text-only client st…
plot_porkchopPlot Porkchopread-only
Render a porkchop C3 contour as a PNG from an existing porkchop grid result, reusing the computed grid with no recompute, and keep the inline grid summary (best cell C3 / total delta-v / epochs). e.g. plot_porkchop(porkchop_result=<porkchop output with output='full'>) for an Earth-Mars 2026 window. The result MUST carry the full grid — call porkchop with output='full' first; a summary-only result (empty grid) returns a typed error, never an empty image. The minimum-delta-v 'best' cell is marked on the contour. The PNG is additive — the numeric summary is always inline. Client renders the retur…
plot_trajectoryPlot Trajectoryread-only
Render an orbit or transfer trajectory as a 2D or 3D PNG about a central body, with an inline summary (arc length, periapsis / apoapsis, time span) carried alongside the image. e.g. plot_trajectory(states=<state series>, projection='2D', central_body='earth') for a GTO arc. Pass the whole state SERIES, not a single state. Positions are plotted in the states' own frame axes (km); in a 2D plot the central body is drawn at the origin to scale for known bodies, while a 3D plot marks the origin (no to-scale sphere). The PNG is additive — the numeric summary (arc length km, apsides km) is always inl…
porkchopPorkchop Plotread-only
Generate an interplanetary porkchop scan — the (depart_epoch x arrive_epoch) grid of C3, arrival V-infinity, declination of the departure asymptote, and total-Δv proxy for a heliocentric transfer. e.g. porkchop(departure_body='earth', arrival_body='mars', depart_window=['2026-10-01T00:00:00Z','2026-12-01T00:00:00Z'], arrive_window=['2027-04-01T00:00:00Z','2027-10-01T00:00:00Z'], samples_per_axis=20) returns the minimum-total_dv 'best' cell, the five lowest-total_dv cells, and a compact ASCII contour for inline LLM display. Both windows are UTC ISO 8601 pairs [start, end]; the grid is samples_p…
satellite_metadataSatellite Metadataread-only
Look up persistent satellite metadata from the ESA DISCOSweb catalogue by NORAD catalogue ID. Returns information the OMM payload from tle_lookup does not carry: mass, bounding-box dimensions, launch date and site, owner / operator, mission type (Payload / Rocket Body / Debris / Unknown), and decay status. Use this to cross-reference results from tle_lookup (NORAD ID is the shared key between the two tools), to filter by physical properties (e.g. distinguish a CubeSat from an ISS-class platform), to sanity-check an OMM (e.g. confirm a launch epoch is consistent with the EPOCH field), or to ver…

Show 10 more tools

sgp4_propagateSGP4 Propagateread-only
Propagate a TLE forward in time via SGP4/SDP4, returning Cartesian state vectors at the requested epochs. TLE input is either two raw 69-char lines (`{line1, line2}`) or a parsed OMM JSON object (`{omm: {...}}`). e.g. sgp4_propagate(tle={line1: ..., line2: ...}, epochs=['2026-05-23T12:00:00Z'], frame='TEME') returns one state vector in TEME. Epochs are UTC ISO 8601 with a mandatory time component (e.g. '2026-05-23T12:00:00Z') — a bare date is rejected. Default frame is TEME (SGP4's native output); for ICRF, GCRS, ITRS, or CIRS the tool transforms via astropy with per-epoch obstime. A list of o…
spice_body_parametersSPICE Body Parametersread-only
Read physical and orientation constants for a body from furnished PCK kernels — triaxial radii (km), GM (km^3/s^2), and the pole / prime-meridian orientation coefficients — e.g. spice_body_parameters(body='MARS') returns Mars's triaxial radii and GM (the default common set), and spice_body_parameters(body='499', parameters=['radii','pole_ra','pm']) adds the orientation coefficients. `body` accepts a name ('MARS') or a NAIF ID as a string ('499'). `parameters` names the constants to fetch — radii, gm, pole_ra, pole_dec, pm — or is omitted for the common set (radii + gm). Each constant comes bac…
spice_frame_transformSPICE Frame Transformread-only
Rotate a vector between SPICE reference frames defined by furnished FK / PCK kernels at an epoch — in particular the non-Earth body-fixed frames the kernel-free frame_transform tool cannot provide. e.g. spice_frame_transform(from_frame='J2000', to_frame='IAU_MARS', epoch='2026-01-01T00:00:00Z', state={position: {value: [4000, 5000, 6000], unit: 'km'}}) rotates a position into the Mars body-fixed frame (a Mars PCK must be furnished first). Omit `state` to get just the 3x3 rotation matrix; pass position only for a pxform rotation, or position+velocity for the full sxform state rotation (which fo…
spice_list_kernelsSPICE List Kernelsread-only
List the SPICE kernels currently furnished in the process kernel pool, e.g. spice_list_kernels() to confirm a leap-second kernel and an SPK are both loaded before a state query, or spice_list_kernels(kind=['SPK','PCK']) to see only the ephemeris and planetary-constants kernels. Each row carries the kernel's name, type (SPK / CK / PCK / EK / DSK / META / TEXT), provenance, and handle. The pool is process-global, so on an HTTP deployment this reports every caller's kernels, not just yours.
spice_load_kernelSPICE Load Kernel
Furnish a SPICE kernel into the process kernel pool from a local path or a NAIF https URL, so later spice_* queries can read it, e.g. spice_load_kernel('https://naif.jpl.nasa.gov/pub/naif/generic_kernels/lsk/naif0012.tls') furnishes a generic leap-second kernel. The pool is additive and persists across calls — load a leap-second kernel (LSK) before any time conversion, and a planetary SPK before a state query; both stay loaded together. A meta-kernel (.tm) furnishes everything it lists in one call, so `loaded` may contain several kernels of several types. URL sources must be on the NAIF allowl…
spice_stateSPICE Stateread-only
Query the state — position (km) and velocity (km/s) — of a target body relative to an observer body at one or more epochs, read from furnished SPK kernels, e.g. spice_state(target='MOON', observer='EARTH', epochs=['2026-01-01T00:00:00Z']) returns the Moon's geocentric state in J2000 (CSPICE's name for the Earth-mean-equator/equinox-of-J2000 inertial frame, aligned with ICRF to milliarcsecond level). Requires the relevant SPK *and* a leap-second kernel (LSK) furnished first via spice_load_kernel — a missing kernel returns a typed error, never a silent empty state. Each epoch must be UTC ISO 860…
spice_time_convertSPICE Time Convertread-only
Convert a time between SPICE kernel-defined systems — ET (TDB seconds past J2000), UTC, and SCLK (spacecraft clock) — using the furnished leap-second and spacecraft-clock kernels. e.g. spice_time_convert(value='2026-01-01T00:00:00Z', from_scale='UTC', to_scale='ET') returns {value: 820497669.184, unit: 's past J2000 TDB'}, the ephemeris time for that UTC epoch; spice_time_convert(value='2026-01-01T00:00:00Z', from_scale='UTC', to_scale='SCLK', spacecraft=-82) returns the Cassini spacecraft-clock string for it. ET output is a {value, unit} quantity in 's past J2000 TDB'; UTC output is an ISO 86…
spice_unload_kernelSPICE Unload Kernel
Unload a previously furnished SPICE kernel from the process kernel pool, e.g. spice_unload_kernel('/path/to/de440.bsp') to drop a stale ephemeris before furnishing a newer one. Unload by the `name` returned from spice_load_kernel (or shown by spice_list_kernels), not the original URL — a name that is not loaded is a typed error rather than a silent no-op. Returns the remaining pool count.
time_convertTime-Scale Convertread-only
Convert a time value between scales (UTC / TAI / TT / TDB / UT1 / GPS / TCB / TCG) and formats (iso / jd / mjd / j2000_seconds / unix). e.g. time_convert(value='2026-05-23T12:00:00', from_scale='UTC', to_scale='TAI') returns '2026-05-23T12:00:37' (the current leap-second-aware offset). UTC -> TAI is exactly TAI - UTC = 37 s as of 2026 but historical conversions need leap-second-aware machinery — don't subtract 37 yourself; the tool does it right. GPS -> UTC respects the GPS-UTC offset (currently 18 s). UTC -> UT1 sources the small (<1 s) offset from IERS Bulletin A — the response includes `ut1…
tle_lookupTLE Lookupread-only
Fetch current two-line element sets (TLEs) from CelesTrak or Space-Track by NORAD catalogue ID or satellite name; CelesTrak additionally supports a group/category keyword for bulk fetches. Returns parsed OMM JSON plus the raw two-line strings. e.g. tle_lookup('25544') for the ISS, tle_lookup('HST') for the Hubble Space Telescope, or tle_lookup('stations') for the multi-satellite space-stations category. Name parameters are case-insensitive substring matches against the catalog name, which is often abbreviated — Hubble Space Telescope is 'HST', not 'HUBBLE' (a name search for 'HUBBLE' returns u…

Signals

Stars: 2
Forks: 0
Open issues: 0
Weekly downloads: 65
Last commit: Jun 7, 2026 (4 months ago)
Last release: Jun 7, 2026 (4 months ago)
Last package publish: Jun 7, 2026 (4 months ago)

From GitHub (fetched Oct 24, 2026) and the package registry.

Details

Registry name: io.github.astro-tools/astrodynamics-mcp
Version: 0.4.0
Auth: No auth
Packages: pypi astrodynamics-mcp
License: MIT
Repository: github.com/astro-tools/astrodynamics-mcp
First seen: Oct 24, 2026
Last checked: Oct 25, 2026
Source: Official MCP Registry github-graphql