Aerospace MCP

Instructions

Implementation Reference

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

  Import of the optimize_thrust_profile tool handler from tools/optimization.py

  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:124-124 (registration)

  MCP registration of the optimize_thrust_profile tool handler

  mcp.tool(optimize_thrust_profile)

• aerospace_mcp/tools/optimization.py:10-65 (handler)

  MCP tool handler: wrapper that converts inputs to RocketGeometry, delegates to trajopt implementation, formats results as JSON string

  def optimize_thrust_profile(
      rocket_geometry: dict,
      burn_time_s: float,
      total_impulse_target: float,
      n_segments: int = 5,
      objective: Literal[
          "max_altitude", "min_max_q", "min_gravity_loss"
      ] = "max_altitude",
  ) -> str:
      """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
      """
      try:
          from ..integrations.trajopt import (
              RocketGeometry,
          )
          from ..integrations.trajopt import (
              optimize_thrust_profile as _optimize,
          )
  
          geometry = RocketGeometry(**rocket_geometry)
  
          result = _optimize(
              geometry, burn_time_s, total_impulse_target, n_segments, objective
          )
  
          return json.dumps(
              {
                  "optimization_result": result.optimization_result,
                  "optimal_objective": result.optimal_objective,
                  "optimal_parameters": result.optimal_parameters,
                  "performance": {
                      "max_altitude_m": result.performance.max_altitude_m,
                      "max_velocity_ms": result.performance.max_velocity_ms,
                      "total_impulse_ns": result.performance.total_impulse_ns,
                      "apogee_time_s": result.performance.apogee_time_s,
                  },
              },
              indent=2,
          )
  
      except ImportError:
          return "Trajectory optimization not available - install optimization packages"
      except Exception as e:
          logger.error(f"Thrust profile optimization error: {str(e)}", exc_info=True)
          return f"Thrust profile optimization error: {str(e)}"

• aerospace_mcp/integrations/trajopt.py:207-353 (helper)

  Core helper implementation: optimizes thrust multipliers using simple gradient descent, normalizes thrust curve to target impulse, simulates trajectory with rocket_3dof_trajectory, returns structured TrajectoryOptimizationResult

  def optimize_thrust_profile(
      geometry: RocketGeometry,
      burn_time_s: float,
      total_impulse_target: float,
      n_segments: int = 5,
      objective: str = "max_altitude",
  ) -> TrajectoryOptimizationResult:
      """
      Optimize thrust profile for better performance.
  
      Args:
          geometry: Base rocket geometry
          burn_time_s: Total burn time
          total_impulse_target: Target total impulse
          n_segments: Number of thrust profile segments
          objective: "max_altitude", "min_max_q", or "min_gravity_loss"
  
      Returns:
          Optimization result
      """
      # Create initial thrust profile (constant thrust)
      avg_thrust = total_impulse_target / burn_time_s
      segment_time = burn_time_s / n_segments
  
      # Initial parameters: thrust multipliers for each segment
      initial_multipliers = [1.0] * n_segments
      multiplier_bounds = [(0.1, 3.0)] * n_segments  # 10% to 300% of average
  
      def objective_function(multipliers: list[float]) -> float:
          """Objective function for thrust profile optimization."""
          try:
              # Create thrust curve from multipliers
              thrust_curve = []
              for i, mult in enumerate(multipliers):
                  time_start = i * segment_time
                  time_end = (i + 1) * segment_time
                  thrust_level = avg_thrust * mult
                  thrust_curve.append([time_start, thrust_level])
                  if i == len(multipliers) - 1:  # Last segment
                      thrust_curve.append([time_end, 0.0])  # End thrust
  
              # Normalize to maintain total impulse
              current_impulse = sum(
                  avg_thrust * mult * segment_time for mult in multipliers
              )
              if current_impulse <= 0:
                  return float("inf")
  
              scale_factor = total_impulse_target / current_impulse
              thrust_curve = [[t, thrust * scale_factor] for t, thrust in thrust_curve]
  
              # Update geometry with new thrust curve
              opt_geometry = RocketGeometry(
                  dry_mass_kg=geometry.dry_mass_kg,
                  propellant_mass_kg=geometry.propellant_mass_kg,
                  diameter_m=geometry.diameter_m,
                  length_m=geometry.length_m,
                  cd=geometry.cd,
                  thrust_curve=thrust_curve,
              )
  
              # Run trajectory simulation with reasonable parameters
              trajectory = rocket_3dof_trajectory(
                  opt_geometry, dt_s=0.2, max_time_s=150.0
              )
              if not trajectory:
                  return 1e6  # Large penalty instead of inf
  
              performance = analyze_rocket_performance(trajectory)
  
              if objective == "max_altitude":
                  # Return negative altitude for minimization, but ensure it's not zero
                  result = -max(
                      1.0, performance.max_altitude_m
                  )  # At least -1 to avoid zero
                  return result
              elif objective == "min_max_q":
                  return performance.max_q_pa
              elif objective == "min_gravity_loss":
                  # Estimate gravity loss (simplified)
                  gravity_loss = 9.80665 * performance.burnout_time_s
                  return gravity_loss
              else:
                  return 1e6
  
          except Exception:
              return 1e6  # Large penalty for failed cases
  
      # Optimize using gradient descent
      optimal_multipliers, optimal_value, iterations, converged = simple_gradient_descent(
          objective_function,
          initial_multipliers,
          multiplier_bounds,
          learning_rate=0.05,
          tolerance=1e-3,
          max_iterations=100,
      )
  
      # Generate final thrust curve and trajectory
      final_thrust_curve = []
      for i, mult in enumerate(optimal_multipliers):
          time_start = i * segment_time
          time_end = (i + 1) * segment_time
          thrust_level = avg_thrust * mult
          final_thrust_curve.append([time_start, thrust_level])
          if i == len(optimal_multipliers) - 1:
              final_thrust_curve.append([time_end, 0.0])
  
      # Normalize final curve
      current_impulse = sum(
          avg_thrust * mult * segment_time for mult in optimal_multipliers
      )
      scale_factor = total_impulse_target / current_impulse
      final_thrust_curve = [
          [t, thrust * scale_factor] for t, thrust in final_thrust_curve
      ]
  
      # Generate final trajectory
      final_geometry = RocketGeometry(
          dry_mass_kg=geometry.dry_mass_kg,
          propellant_mass_kg=geometry.propellant_mass_kg,
          diameter_m=geometry.diameter_m,
          length_m=geometry.length_m,
          cd=geometry.cd,
          thrust_curve=final_thrust_curve,
      )
  
      final_trajectory = rocket_3dof_trajectory(final_geometry)
      final_performance = analyze_rocket_performance(final_trajectory)
  
      # Prepare optimal parameters
      optimal_params = {
          f"thrust_mult_seg_{i + 1}": mult for i, mult in enumerate(optimal_multipliers)
      }
      optimal_params["thrust_curve"] = final_thrust_curve
  
      return TrajectoryOptimizationResult(
          optimal_parameters=optimal_params,
          optimal_objective=(
              -optimal_value if objective == "max_altitude" else optimal_value
          ),
          iterations=iterations,
          converged=converged,
          trajectory_points=final_trajectory,
          performance=final_performance,
      )