Aerospace MCP

Instructions

Implementation Reference

• aerospace_mcp/tools/optimization.py:67-101 (handler)

  Main MCP tool handler for trajectory_sensitivity_analysis. Parses input dicts into RocketGeometry, delegates to trajopt implementation, and returns JSON results or error messages.

  def trajectory_sensitivity_analysis(
      rocket_geometry: dict,
      parameter_variations: dict,
      analysis_options: dict | None = None,
  ) -> str:
      """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
      """
      try:
          from ..integrations.trajopt import (
              RocketGeometry,
          )
          from ..integrations.trajopt import (
              trajectory_sensitivity_analysis as _sensitivity,
          )
  
          geometry = RocketGeometry(**rocket_geometry)
  
          result = _sensitivity(geometry, parameter_variations, analysis_options or {})
  
          return json.dumps(result, indent=2)
  
      except ImportError:
          return "Sensitivity analysis not available - install optimization packages"
      except Exception as e:
          logger.error(f"Sensitivity analysis error: {str(e)}", exc_info=True)
          return f"Sensitivity analysis error: {str(e)}"

• aerospace_mcp/fastmcp_server.py:48-55 (registration)

  Import statement in fastmcp_server.py that brings the trajectory_sensitivity_analysis handler into scope for registration.

  from .tools.optimization import (
      genetic_algorithm_optimization,
      monte_carlo_uncertainty_analysis,
      optimize_thrust_profile,
      particle_swarm_optimization,
      porkchop_plot_analysis,
      trajectory_sensitivity_analysis,
  )

• aerospace_mcp/fastmcp_server.py:125-125 (registration)

  Explicit registration of the trajectory_sensitivity_analysis tool with the FastMCP server.

  mcp.tool(trajectory_sensitivity_analysis)

• aerospace_mcp/integrations/trajopt.py:417-525 (helper)

  Core helper function implementing the sensitivity analysis logic by varying parameters, running simulations, and computing percent changes and sensitivities.

  def trajectory_sensitivity_analysis(
      base_geometry: RocketGeometry,
      parameter_variations: dict[str, list[float]],
      objective: str = "max_altitude",
  ) -> dict[str, Any]:
      """
      Perform sensitivity analysis on trajectory parameters.
  
      Args:
          base_geometry: Baseline rocket geometry
          parameter_variations: Dict with parameter names and variation values
          objective: Objective to analyze sensitivity for
  
      Returns:
          Sensitivity analysis results
      """
      baseline_trajectory = rocket_3dof_trajectory(base_geometry)
      baseline_performance = analyze_rocket_performance(baseline_trajectory)
  
      if objective == "max_altitude":
          baseline_value = baseline_performance.max_altitude_m
      elif objective == "max_velocity":
          baseline_value = baseline_performance.max_velocity_ms
      elif objective == "specific_impulse":
          baseline_value = baseline_performance.specific_impulse_s
      else:
          baseline_value = baseline_performance.max_altitude_m
  
      sensitivity_results = {}
  
      for param_name, variations in parameter_variations.items():
          param_results = []
  
          for variation in variations:
              # Create modified geometry
              modified_geometry = RocketGeometry(
                  dry_mass_kg=base_geometry.dry_mass_kg,
                  propellant_mass_kg=base_geometry.propellant_mass_kg,
                  diameter_m=base_geometry.diameter_m,
                  length_m=base_geometry.length_m,
                  cd=base_geometry.cd,
                  thrust_curve=base_geometry.thrust_curve,
              )
  
              # Apply variation
              if param_name == "dry_mass_kg":
                  modified_geometry.dry_mass_kg = variation
              elif param_name == "propellant_mass_kg":
                  modified_geometry.propellant_mass_kg = variation
              elif param_name == "diameter_m":
                  modified_geometry.diameter_m = variation
              elif param_name == "cd":
                  modified_geometry.cd = variation
  
              try:
                  trajectory = rocket_3dof_trajectory(modified_geometry)
                  performance = analyze_rocket_performance(trajectory)
  
                  if objective == "max_altitude":
                      current_value = performance.max_altitude_m
                  elif objective == "max_velocity":
                      current_value = performance.max_velocity_ms
                  elif objective == "specific_impulse":
                      current_value = performance.specific_impulse_s
                  else:
                      current_value = performance.max_altitude_m
  
                  # Calculate sensitivity
                  percent_change_param = (
                      (variation - getattr(base_geometry, param_name))
                      / getattr(base_geometry, param_name)
                      * 100
                  )
                  percent_change_objective = (
                      (current_value - baseline_value) / baseline_value * 100
                  )
                  sensitivity = (
                      percent_change_objective / percent_change_param
                      if percent_change_param != 0
                      else 0
                  )
  
                  param_results.append(
                      {
                          "parameter_value": variation,
                          "objective_value": current_value,
                          "percent_change_param": percent_change_param,
                          "percent_change_objective": percent_change_objective,
                          "sensitivity": sensitivity,
                      }
                  )
              except Exception:
                  param_results.append(
                      {
                          "parameter_value": variation,
                          "error": "Simulation failed",
                          "sensitivity": None,
                      }
                  )
  
          sensitivity_results[param_name] = param_results
  
      return {
          "baseline_value": baseline_value,
          "objective": objective,
          "parameter_sensitivities": sensitivity_results,
          "baseline_geometry": asdict(base_geometry),
      }