Search for aerospace-mcp tools by name, description, or functionality.

This tool enables dynamic tool discovery, allowing Claude to find relevant tools from the 34+ available aerospace tools without loading all definitions upfront. Returns tool references matching the search query.

Args: query: Search query - regex pattern (for regex mode) or natural language (for text mode) search_type: Search mode - 'regex' for pattern matching, 'text' for natural language, 'auto' to detect based on query characteristics max_results: Maximum number of tools to return (default 5, max 10) category: Optional category filter (core, atmosphere, frames, aerodynamics, propellers, rockets, orbits, optimization, agents)

Returns: JSON string with tool references matching the query, including both machine-readable tool_reference blocks and human-readable details.

Raises: No exceptions are raised directly; errors are returned in JSON format.

List all available tool categories with tool counts.

Returns: JSON string with an array of categories (name and tool_count) and the total number of registered tools.

Search for airports by IATA code or city name.

Args: query: IATA code (e.g., 'SJC') or city name (e.g., 'San Jose') country: Optional ISO country code to filter by (e.g., 'US', 'JP') query_type: Type of query - 'iata' for IATA codes, 'city' for city names, 'auto' to detect

Returns: Formatted string with airport information

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Plan a flight route between two airports with performance estimates.

Args: departure: Dict with departure info (city, country, iata) arrival: Dict with arrival info (city, country, iata) aircraft: Optional aircraft config (ac_type, cruise_alt_ft, route_step_km) route_options: Optional route options

Returns: JSON string with flight plan details including departure/arrival airports, route waypoints, distances, and optional performance estimates.

Raises: No exceptions are raised directly; errors are returned as formatted strings. Internally catches AirportResolutionError and OpenAPError.

Calculate great circle distance between two points.

Args: lat1: Latitude of first point in degrees lon1: Longitude of first point in degrees lat2: Latitude of second point in degrees lon2: Longitude of second point in degrees

Returns: JSON string with distance in km and NM, plus initial/final bearings.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Get performance estimates for an aircraft type (requires OpenAP).

Args: aircraft_type: ICAO aircraft type code (e.g., 'A320', 'B737') distance_km: Flight distance in kilometers cruise_altitude_ft: Cruise altitude in feet

Returns: JSON string with performance estimates or error message.

Raises: No exceptions are raised directly; errors are returned as formatted strings. Internally catches OpenAPError for unsupported aircraft types.

Get system status and capabilities.

Returns: JSON string with system status information

Get atmospheric properties (pressure, temperature, density) at specified altitudes using ISA model.

Args: altitudes_m: List of altitudes in meters model_type: Atmospheric model type ('ISA' for standard, 'enhanced' for extended)

Returns: Formatted string with atmospheric profile data including pressure, temperature, density, and speed of sound at each altitude.

Raises: No exceptions are raised directly; errors are returned as formatted strings. ImportError is caught when the ambiance package is not installed.

Calculate wind speeds at different altitudes using logarithmic or power law models.

Args: altitudes_m: List of altitudes in meters surface_wind_speed_ms: Wind speed at 10m reference height in m/s surface_wind_direction_deg: Wind direction at surface in degrees (0=North, 90=East) model_type: Wind model type ('logarithmic' or 'power_law') roughness_length_m: Surface roughness length in meters

Returns: Formatted string with wind profile data at each requested altitude.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: The logarithmic wind profile (Ref: Stull, "Meteorology for Scientists and Engineers", 2000) models wind speed as: U(z) = (u* / kappa) * ln(z / z0) where u* is friction velocity, kappa ~0.4 is the von Karman constant, and z0 is the aerodynamic roughness length.

The **power-law wind profile** (empirical approximation) models wind as:
    U(z) = U_ref * (z / z_ref) ^ alpha
where alpha (Hellmann exponent) depends on terrain roughness, typically
~0.14 for open terrain and ~0.40 for urban areas.

Transform coordinates between reference frames (ECEF, ECI, ITRF, GCRS, GEODETIC).

Args: coordinates: Dict with coordinate data (format depends on frame) from_frame: Source reference frame to_frame: Target reference frame epoch_utc: Optional epoch for time-dependent transformations (ISO format)

Returns: JSON string with transformed coordinates in the target frame.

Raises: No exceptions are raised directly; errors are returned as formatted strings. ImportError is caught when required frame transformation packages are missing.

Convert geodetic coordinates (lat/lon/alt) to Earth-centered Earth-fixed (ECEF) coordinates.

Args: latitude_deg: Latitude in degrees (-90 to 90) longitude_deg: Longitude in degrees (-180 to 180) altitude_m: Altitude above WGS84 ellipsoid in meters

Returns: JSON string with ECEF X, Y, Z coordinates in meters.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: The geodetic-to-ECEF conversion uses the WGS84 ellipsoid parameters: a = 6378137.0 m (semi-major axis, equatorial radius) f = 1/298.257223563 (flattening) e^2 = 2f - f^2 (first eccentricity squared)

The conversion equations are:
    N = a / sqrt(1 - e^2 * sin^2(lat))   (radius of curvature in prime vertical)
    X = (N + h) * cos(lat) * cos(lon)
    Y = (N + h) * cos(lat) * sin(lon)
    Z = (N * (1 - e^2) + h) * sin(lat)
where lat, lon are geodetic latitude/longitude and h is altitude above ellipsoid.

Convert ECEF coordinates to geodetic (lat/lon/alt) coordinates.

Args: x_m: X coordinate in meters y_m: Y coordinate in meters z_m: Z coordinate in meters

Returns: JSON string with geodetic latitude (deg), longitude (deg), and altitude (m).

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Analyze wing aerodynamics using Vortex Lattice Method or simplified lifting line theory.

Args: wing_config: Wing configuration with keys: - span_m: Wing span in meters - chord_root_m: Root chord in meters - chord_tip_m: Tip chord in meters (optional, defaults to chord_root_m) - sweep_deg: Quarter-chord sweep in degrees (optional, default 0) - dihedral_deg: Dihedral angle in degrees (optional, default 0) - twist_deg: Tip twist in degrees (optional, default 0) - airfoil_root: Root airfoil name (optional, default 'NACA2412') - airfoil_tip: Tip airfoil name (optional, default matches root) flight_conditions: Flight conditions with keys: - alpha_deg_list: List of angles of attack to analyze (required) - mach: Mach number (optional, default 0.2) - reynolds: Reynolds number (optional) analysis_options: Optional analysis settings (currently unused)

Returns: Formatted string with aerodynamic analysis results including CL, CD, CM, and L/D ratio at each angle of attack.

Raises: No exceptions are raised directly; errors are returned as formatted strings. ImportError is caught when aerodynamics packages are not installed.

Note: The Vortex Lattice Method (VLM) discretizes the wing planform into panels, each modeled with a horseshoe vortex. Each horseshoe vortex consists of a bound vortex along the panel quarter-chord line and two trailing (semi-infinite) vortices extending downstream. The induced velocity at each panel's 3/4-chord control point is computed via the Biot-Savart law, and the no-penetration boundary condition is enforced to solve for the vortex strengths (circulation distribution).

Generate airfoil polar data (CL, CD, CM vs alpha) using database or advanced methods.

Args: airfoil_name: Airfoil name (e.g., 'NACA2412', 'NACA0012') reynolds_number: Reynolds number mach_number: Mach number alpha_range_deg: Optional angle of attack range, defaults to [-10, 20] deg

Returns: Formatted string with airfoil polar data (CL, CD, CM, L/D vs. alpha).

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate basic longitudinal stability derivatives for a wing.

Args: wing_config: Wing configuration with keys: - span_m: Wing span in meters - chord_root_m: Root chord in meters - chord_tip_m: Tip chord in meters (optional) - sweep_deg: Quarter-chord sweep (optional, default 0) - dihedral_deg: Dihedral angle (optional, default 0) - twist_deg: Tip twist (optional, default 0) - airfoil_root: Root airfoil name (optional, default 'NACA2412') - airfoil_tip: Tip airfoil name (optional) flight_conditions: Flight conditions with keys: - alpha_deg: Reference angle of attack (optional, default 2.0) - mach: Mach number (optional, default 0.2)

Returns: JSON string with stability derivatives: - CL_alpha: Lift curve slope (dCL/dalpha) [1/rad] -- rate of lift change with angle of attack. Positive for conventional aircraft. - CM_alpha: Pitching moment slope (dCM/dalpha) [1/rad] -- must be negative for static longitudinal stability (nose-down restoring moment). - CL_alpha_dot: Unsteady lift derivative due to rate of alpha change. - CM_alpha_dot: Unsteady pitching moment derivative (pitch damping).

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Get available airfoil database with aerodynamic coefficients.

Returns: JSON string with airfoil database containing aerodynamic coefficients.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Analyze propeller performance using Blade Element Momentum Theory.

Args: propeller_geometry: Propeller geometry (diameter_m, pitch_m, num_blades, etc.) operating_conditions: Operating conditions (rpm_list, velocity_ms, altitude_m) analysis_options: Optional analysis settings

Returns: Formatted string with propeller performance analysis including thrust, torque, power, efficiency, and advance ratio at each RPM.

Raises: No exceptions are raised directly; errors are returned as formatted strings. ImportError is caught when propulsion packages are not installed.

Note: BEMT iteratively solves for the inflow angle (phi) at each blade element by balancing: 1. Blade Element Theory: Local lift and drag from 2D airfoil data at the effective angle of attack (alpha = phi - pitch_angle). 2. Momentum Theory: Axial and tangential momentum changes through an annular ring of the rotor disk. Convergence is achieved when the induced velocity factors (a, a') satisfy both theories simultaneously. The advance ratio J = V / (n*D) characterizes the operating condition.

Estimate UAV flight time and energy consumption for mission planning.

Args: uav_config: UAV configuration parameters battery_config: Battery configuration parameters mission_profile: Optional mission profile parameters

Returns: Formatted string with energy analysis results including flight time, range, hover time, power required, and efficiency metrics.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Get available propeller database with geometric and performance data.

Returns: JSON string with propeller database containing geometry and performance data.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate 3DOF rocket trajectory using numerical integration.

Args: rocket_geometry: Rocket geometry parameters launch_conditions: Launch conditions (launch_angle_deg, launch_site, etc.) simulation_options: Optional simulation settings

Returns: Formatted string with trajectory analysis results including max altitude, max velocity, Mach number, apogee time, burnout time, max-Q, total impulse, and specific impulse.

Raises: No exceptions are raised directly; errors are returned as formatted strings. ImportError is caught when rocketry packages are not installed.

Note: The 3DOF equations of motion integrate: dv/dt = (T - D) / m - g * sin(gamma) (along velocity) dgamma/dt = -(g / v) * cos(gamma) (flight path angle) dx/dt = v * cos(gamma) (downrange) dh/dt = v * sin(gamma) (altitude) where T is thrust, D = 0.5 * rho(h) * v^2 * Cd * A_ref is aerodynamic drag with altitude-dependent density, m is instantaneous mass (decreasing during burn), and gamma is the flight path angle. Integration uses a 4th-order Runge-Kutta (RK4) scheme for numerical stability.

Estimate rocket sizing requirements for target altitude and payload.

Args: target_altitude_m: Target altitude in meters payload_mass_kg: Payload mass in kg propellant_type: Propellant type ('solid' or 'liquid') design_margin: Design margin factor

Returns: JSON string with sizing estimates including propellant mass, dry mass, total mass, and structural dimensions.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: Sizing uses the Tsiolkovsky rocket equation (ideal rocket equation): delta_V = Isp * g0 * ln(m_initial / m_final) Rearranged to solve for propellant mass: m_prop = m_final * (exp(delta_V / (Isp * g0)) - 1) where Isp is specific impulse and g0 = 9.80665 m/s^2.

Optimize rocket launch angle for maximum altitude or range.

Args: rocket_geometry: Rocket geometry parameters target_range_m: Optional target range in meters optimize_for: Optimization objective ('altitude' or 'range') angle_bounds_deg: Launch angle bounds in degrees

Returns: JSON string with optimization results including optimal angle and resulting performance metrics.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Convert orbital elements to state vector in J2000 frame.

Args: orbital_elements: Dict with orbital elements (semi_major_axis_m, eccentricity, etc.)

Returns: JSON string with position [x,y,z] in meters and velocity [vx,vy,vz] in m/s in the J2000 inertial frame.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Convert state vector to classical orbital elements.

Args: state_vector: Dict with position_m and velocity_ms arrays

Returns: JSON string with classical orbital elements (a, e, i, RAAN, omega, nu).

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Propagate orbit with J2 perturbations using numerical integration.

Args: initial_state: Initial orbital state (elements or state vector) propagation_time_s: Propagation time in seconds time_step_s: Integration time step in seconds

Returns: JSON string with propagated state vectors at each time step.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate ground track from orbital state vectors.

Args: orbital_state: Orbital state (elements or state vector) duration_s: Duration for ground track calculation in seconds time_step_s: Time step for ground track points in seconds

Returns: JSON string with ground track latitude/longitude coordinates.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate Hohmann transfer orbit parameters between two circular orbits.

Args: r1_m: Initial orbit radius in meters r2_m: Final orbit radius in meters

Returns: JSON string with transfer orbit parameters including delta-V for each burn, transfer orbit semi-major axis, and time of flight.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: The Hohmann transfer is the minimum-energy two-impulse transfer between coplanar circular orbits. Using the vis-viva equation v^2 = mu*(2/r - 1/a): a_transfer = (r1 + r2) / 2 delta_V1 = sqrt(mu/r1) * (sqrt(2r2/(r1+r2)) - 1) (departure burn) delta_V2 = sqrt(mu/r2) * (1 - sqrt(2r1/(r1+r2))) (arrival burn)

Plan orbital rendezvous maneuvers between two spacecraft.

Args: chaser_elements: Chaser spacecraft orbital elements target_elements: Target spacecraft orbital elements rendezvous_options: Optional rendezvous planning parameters

Returns: JSON string with rendezvous plan including maneuver sequence and delta-V.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Solve Lambert's orbital boundary value problem.

Given two position vectors and time-of-flight, determine the orbit connecting them. This is foundational for interplanetary mission design and rendezvous trajectory planning.

Args: r1_m: Initial position vector [x, y, z] in meters r2_m: Final position vector [x, y, z] in meters tof_s: Time of flight in seconds direction: Transfer direction - "prograde" or "retrograde" num_revolutions: Number of complete revolutions (default 0 for short path) central_body: Central body name for gravitational parameter

Returns: JSON string with transfer orbit velocities, orbital elements, transfer angle, and timing information.

Raises: No exceptions are raised directly; errors are returned as JSON strings.

Extended Kalman Filter for aircraft/spacecraft state estimation.

Implements a Kalman filter for sensor fusion and state estimation from noisy measurements.

Args: initial_state: Initial state vector estimate initial_covariance: Initial state covariance matrix (P0) process_noise: Process noise covariance matrix (Q) measurement_noise: Measurement noise covariance matrix (R) measurements: Time-series of measurements, each with: - time: Measurement timestamp - z: Measurement vector - H: Optional measurement matrix (uses identity if not provided) dynamics_model: Dynamics model type: - "constant_velocity": 2D position + velocity - "constant_acceleration": 2D position + velocity + acceleration - "orbital": Simplified orbital dynamics dt: Time step for prediction (used if not in measurements)

Returns: Formatted string with filtered state estimates, covariance diagonals, and innovation statistics.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Design Linear Quadratic Regulator (LQR) optimal controller.

Computes optimal state-feedback gain K that minimizes the cost function: J = integral(x'Qx + u'Ru) dt

Args: A_matrix: State matrix (n x n) - system dynamics B_matrix: Input matrix (n x m) - control influence Q_matrix: State weighting matrix (n x n) - penalizes state deviation R_matrix: Input weighting matrix (m x m) - penalizes control effort state_names: Optional names for states (for display) input_names: Optional names for control inputs (for display)

Returns: Formatted string with optimal gain matrix K, closed-loop eigenvalues, stability analysis, and controllability assessment.

Raises: No exceptions are raised directly; errors are returned as formatted strings or JSON error objects (e.g., when system is not controllable).

Calculate density altitude from pressure altitude and temperature.

Density altitude is the altitude in the standard atmosphere at which the air density equals the actual air density at the given conditions. Essential for aircraft performance calculations.

Args: pressure_altitude_ft: Pressure altitude in feet temperature_c: Outside air temperature in Celsius dewpoint_c: Optional dewpoint for humidity correction

Returns: Formatted string with density altitude calculation results including air density, density ratio (sigma), pressure ratio (delta), and ISA deviation.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Convert between IAS, CAS, EAS, TAS, and Mach number.

Args: speed_value: Input speed value (knots for airspeeds, dimensionless for Mach) speed_type: Input type - "IAS", "CAS", "EAS", "TAS", or "MACH" altitude_ft: Pressure altitude in feet temperature_c: Outside air temperature in Celsius (uses ISA if not provided) position_error_kts: Position error correction in knots (IAS to CAS)

Returns: Formatted string with all equivalent airspeeds (IAS, CAS, EAS, TAS, Mach), dynamic pressure, and atmospheric conditions.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate stall speeds for different aircraft configurations.

Args: weight_kg: Aircraft weight in kg wing_area_m2: Wing reference area in m² cl_max_clean: Maximum lift coefficient in clean configuration cl_max_takeoff: Max CL with takeoff flaps (optional) cl_max_landing: Max CL with landing flaps (optional) altitude_ft: Pressure altitude in feet load_factor: Load factor (default 1.0 for level flight)

Returns: Formatted string with stall speed calculations for each configuration, plus reference speeds (VREF, V2_min) and altitude correction.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate aircraft center of gravity and verify within limits.

Args: basic_empty_weight_kg: Basic empty weight in kg basic_empty_arm_m: Basic empty weight CG arm (from datum) in meters fuel_kg: Fuel load in kg fuel_arm_m: Fuel tank CG arm in meters payload_items: List of payload items, each with keys: - weight_kg: Weight in kg - arm_m: CG arm in meters - name: Item name (optional) forward_cg_limit_m: Forward CG limit (optional) aft_cg_limit_m: Aft CG limit (optional) max_takeoff_weight_kg: Maximum takeoff weight (optional) mac_m: Mean aerodynamic chord length (optional, for %MAC calculation) lemac_m: Leading edge of MAC position (optional, for %MAC calculation)

Returns: Formatted string with weight and balance calculation results.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate takeoff field length and V-speeds.

Uses simplified performance equations for educational purposes.

Args: weight_kg: Takeoff weight in kg pressure_altitude_ft: Airport pressure altitude in feet temperature_c: Outside air temperature in Celsius wind_kts: Headwind (+) or tailwind (-) in knots runway_slope_pct: Runway slope in percent (+ uphill) runway_condition: "dry", "wet", or "contaminated" thrust_to_weight: Thrust-to-weight ratio cl_max_takeoff: Maximum lift coefficient in takeoff config wing_area_m2: Wing reference area in m² cd0: Zero-lift drag coefficient oswald_e: Oswald efficiency factor aspect_ratio: Wing aspect ratio

Returns: Formatted string with takeoff performance calculations including V-speeds, ground roll, air distance to 35 ft, and factored distances.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate landing distance for given conditions.

Args: weight_kg: Landing weight in kg pressure_altitude_ft: Airport pressure altitude in feet temperature_c: Outside air temperature in Celsius wind_kts: Headwind (+) or tailwind (-) in knots runway_slope_pct: Runway slope in percent (+ uphill) runway_condition: "dry", "wet", or "contaminated" cl_max_landing: Maximum lift coefficient in landing config wing_area_m2: Wing reference area in m² vref_factor: Approach speed factor (typically 1.3) approach_angle_deg: Approach angle in degrees

Returns: Formatted string with landing performance calculations including V-speeds, air distance from 50 ft, ground roll, and factored distances.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Calculate required fuel reserves per aviation regulations.

Args: regulation: Regulatory framework - "FAR_91", "FAR_121", "JAR_OPS", or "ICAO" trip_fuel_kg: Planned trip fuel in kg cruise_fuel_flow_kg_hr: Cruise fuel flow rate in kg/hr flight_time_min: Planned flight time in minutes alternate_fuel_kg: Fuel to fly to alternate airport in kg holding_altitude_ft: Expected holding altitude for reserve calculations

Returns: Formatted string with fuel reserve breakdown per the selected regulation, including contingency, alternate, and final reserve components.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Optimize rocket thrust profile for better performance using trajectory optimization.

Args: rocket_geometry: Rocket geometry parameters burn_time_s: Burn time in seconds total_impulse_target: Target total impulse in N⋅s n_segments: Number of thrust segments objective: Optimization objective

Returns: JSON string with optimized thrust profile including segment-wise thrust levels and resulting trajectory performance.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Perform sensitivity analysis on rocket trajectory parameters.

Args: rocket_geometry: Baseline rocket geometry parameter_variations: Parameters to vary and their ranges analysis_options: Optional analysis settings

Returns: JSON string with sensitivity analysis results showing how each parameter variation affects the trajectory outcome.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Optimize spacecraft trajectory using genetic algorithm.

Args: optimization_problem: Problem definition (objective, constraints, variables) ga_parameters: Optional GA parameters (population_size, generations, etc.)

Returns: JSON string with optimization results including best solution found, convergence history, and final objective value.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: The GA operates on a population of candidate solutions through: 1. Selection: Tournament or roulette-wheel selection of parents. 2. Crossover: Combining parent chromosomes (e.g., single-point or uniform crossover) to produce offspring that inherit traits from both. 3. Mutation: Random perturbation of offspring genes with probability p_mutation to maintain diversity and avoid premature convergence. Each generation evaluates fitness, selects the best, and breeds the next generation until convergence or max generations reached.

Optimize spacecraft trajectory using particle swarm optimization.

Args: optimization_problem: Problem definition (objective, constraints, variables) pso_parameters: Optional PSO parameters (n_particles, iterations, etc.)

Returns: JSON string with optimization results including best position found and convergence metrics.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: PSO updates each particle's velocity and position at every iteration: v_i(t+1) = wv_i(t) + c1r1*(p_best_i - x_i) + c2r2(g_best - x_i) x_i(t+1) = x_i(t) + v_i(t+1) where w is the inertia weight (balances exploration vs exploitation), c1/c2 are cognitive/social acceleration coefficients, r1/r2 are random numbers in [0,1], p_best_i is the particle's personal best, and g_best is the global best found by any particle in the swarm.

Generate porkchop plot for interplanetary transfer opportunities.

Args: departure_body: Departure celestial body name arrival_body: Arrival celestial body name departure_date_range: Range of departure dates (ISO format) arrival_date_range: Range of arrival dates (ISO format) analysis_options: Optional analysis settings

Returns: JSON string with porkchop plot data (departure date vs arrival date grid with delta-V contours for identifying optimal launch windows).

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Perform Monte Carlo uncertainty analysis on spacecraft trajectory.

Args: nominal_trajectory: Nominal trajectory parameters uncertainty_parameters: Parameters with uncertainty distributions n_samples: Number of Monte Carlo samples analysis_options: Optional analysis settings

Returns: JSON string with uncertainty analysis results including statistical summaries (mean, std, percentiles) of trajectory metrics.

Raises: No exceptions are raised directly; errors are returned as formatted strings.

Note: Monte Carlo analysis samples uncertain parameters from their specified distributions (e.g., Gaussian, uniform) and runs n_samples trajectory simulations. Statistical analysis of the results provides: - Mean and standard deviation of key performance metrics. - Confidence intervals (e.g., 95th percentile bounds). - Dispersion ellipses for correlated output parameters. Latin Hypercube Sampling (LHS) may be used for efficient coverage of the parameter space with fewer samples than pure random sampling.

Help format data in the correct format for a specific aerospace-mcp tool.

Uses GPT-5-Medium to analyze the user's requirements and raw data, then provides the correctly formatted parameters for the specified tool.

Args: tool_name: Name of the aerospace-mcp tool to format data for user_requirements: Description of what the user wants to accomplish raw_data: Any raw data that needs to be formatted (optional)

Returns: Formatted JSON string with the correct parameters for the tool, or a JSON error object if the tool is not found or LLM call fails.

Raises: No exceptions are raised directly; errors are returned as formatted strings or JSON error objects.

Help select the most appropriate aerospace-mcp tool for a given task.

Uses GPT-5-Medium to analyze the user's task and recommend the best tool(s) along with guidance on how to use them.

Args: user_task: Description of what the user wants to accomplish user_context: Additional context about the user's situation (optional)

Returns: Recommendation with tool name(s) and usage guidance, including primary tool, secondary tools, workflow steps, and considerations.

Raises: No exceptions are raised directly; errors are returned as formatted strings.