Power your agent
Install from the publisher. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
No packaged release in the registry yet. Follow the repository README.
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchA comprehensive aerospace research and flight planning service providing both HTTP API and Model Context Protocol (MCP) integration. Built with FastMCP for streamlined MCP server development. Features intelligent airport resolution, great-circle route calculation, aircraft performance estimation, atmospheric modeling, coordinate frame transformations, aerodynamic analysis, propeller performance modeling, rocket trajectory optimization, orbital mechanics calculations, and spacecraft trajectory planning for aerospace operations.
THIS SOFTWARE IS FOR EDUCATIONAL, RESEARCH, AND DEVELOPMENT PURPOSES ONLY
For real flight planning, always use certified aviation software and consult official sources including NOTAMs, weather reports, and air traffic control.
The only prerequisite is uv, which also fetches Python 3.11+ if your system has none. Releases on PyPI ship prebuilt wheels for Linux (x86_64 and arm64, glibc 2.28+ and musl), macOS 11+ (Intel and Apple Silicon) and Windows x64, so no Rust toolchain or compiler is needed.
curl -LsSf https://astral.sh/uv/install.sh | sh # Linux / macOS
claude plugin marketplace add cheesejaguar/aerospace-mcp && claude plugin install aerospace-mcp@aerospace-mcp
Inside a session (Claude Code 2.1.275 or later) the same is
/plugin install aerospace-mcp --marketplace cheesejaguar/aerospace-mcp. The
plugin starts the MCP server with uvx aerospace-mcp and adds the skills in
skills/. For the MCP server alone:
claude mcp add aerospace -- uvx aerospace-mcp.
npx skills add cheesejaguar/aerospace-mcp
The skills run tools through uvx --from aerospace-mcp aerospace-mcp-cli, so
they need uv too (and Node.js for npx).
{
"mcpServers": {
"aerospace": {
"command": "uvx",
"args": ["aerospace-mcp"]
}
}
}
GUI apps on macOS do not inherit your shell's PATH: if the client cannot
find uvx, use the absolute path printed by which uvx (usually
~/.local/bin/uvx). The first launch downloads about 300 MB of dependencies;
run uvx --from aerospace-mcp aerospace-mcp-cli list once beforehand so the
client's server start-up timeout is not spent on the download.
uvx --from aerospace-mcp aerospace-mcp-cli run hohmann_transfer --r1_m 6778000 --r2_m 42164000
uvx --from aerospace-mcp aerospace-mcp-http # http://localhost:8080/docs
uv tool install aerospace-mcp # all three commands on PATH
Optional extras work the same way, e.g. uvx --from 'aerospace-mcp[llm]' aerospace-mcp for the LLM agent tools (set LLM_TOOLS_ENABLED=true and
OPENAI_API_KEY).
Building from a checkout compiles the native core, so it needs a Rust toolchain:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Rust (rustup)
git clone https://github.com/cheesejaguar/aerospace-mcp.git
cd aerospace-mcp
uv sync # builds aerospace_mcp._native
cp .env.example .env # optional: host/port/log level, LLM tools
uv run aerospace-mcp # MCP server (stdio)
uv run aerospace-mcp sse 0.0.0.0 8001 # MCP server (SSE, debugging)
uv run aerospace-mcp-http # HTTP API
uvicorn main:app --reload --port 8080 # HTTP API with auto-reload
git clone https://github.com/cheesejaguar/aerospace-mcp.git
cd aerospace-mcp
docker build -t aerospace-mcp .
docker run -p 8080:8080 aerospace-mcp
# Test the API
curl "http://localhost:8080/health"
plan_multi_leg_flight, 2-10 waypoints with aggregated totals)get_aircraft_database)[llm])uvx aerospace-mcp # MCP server (stdio), run in place
uvx --from aerospace-mcp aerospace-mcp-cli list # any command, run in place
uv tool install aerospace-mcp # install the commands on PATH
uv tool upgrade aerospace-mcp # later: upgrade
uvx caches the environment after the first run. To pick up a new release
with uvx, run uvx aerospace-mcp@latest once.
python3 -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate
python -m pip install --upgrade pip # old pips miss the manylinux_2_28 / musllinux wheels
pip install aerospace-mcp # or 'aerospace-mcp[llm]', 'aerospace-mcp[all]'
aerospace-mcp-cli list
Extras: llm (LLM agent tools), atmosphere, aircraft, rockets,
space, gnc, all.
See From source (development): uv sync (or
pip install -e .) in a checkout, with Rust installed via
rustup.
git clone https://github.com/cheesejaguar/aerospace-mcp.git
cd aerospace-mcp
docker build -t aerospace-mcp .
docker run -d -p 8080:8080 --name aerospace-mcp aerospace-mcp
curl http://localhost:8080/health
The image builds the native core itself (Rust is installed in the build
stage only) and includes the llm extra.
The MCP client cannot start the server / uvx: command not found: GUI
apps (Claude Desktop on macOS in particular) do not see the PATH from your
shell profile. Put the absolute path from which uvx in the command field.
The MCP client times out on first launch: the first uvx run downloads
the dependencies. Run uvx --from aerospace-mcp aerospace-mcp-cli list once
in a terminal, then restart the client.
error: can't find Rust compiler / Failed to build aerospace-mcp: the
installer found no wheel for your platform and fell back to the source
distribution. Upgrade pip (python -m pip install --upgrade pip); if your
platform has no prebuilt wheel (see above), install Rust with
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh and retry.
LLM agent tools report that LiteLLM is not installed: install the llm
extra (pip install 'aerospace-mcp[llm]', or
uvx --from 'aerospace-mcp[llm]' aerospace-mcp).
Check an installation:
aerospace-mcp-cli run get_system_status # optional packages and their versions
aerospace-mcp-cli run hohmann_transfer --r1_m 6778000 --r2_m 42164000
# Plan a simple flight
curl -X POST "http://localhost:8080/plan" \
-H "Content-Type: application/json" \
-d '{
"depart_city": "San Francisco",
"arrive_city": "New York",
"ac_type": "A320",
"cruise_alt_ft": 37000,
"backend": "openap"
}'
# Find airports by city
curl "http://localhost:8080/airports/by_city?city=Tokyo"
# Filter by country
curl "http://localhost:8080/airports/by_city?city=London&country=GB"
# Multiple results
curl "http://localhost:8080/airports/by_city?city=Paris"
# Specify exact airports and aircraft mass
curl -X POST "http://localhost:8080/plan" \
-H "Content-Type: application/json" \
-d '{
"depart_city": "Los Angeles",
"arrive_city": "Tokyo",
"prefer_depart_iata": "LAX",
"prefer_arrive_iata": "NRT",
"ac_type": "B777",
"cruise_alt_ft": 39000,
"mass_kg": 220000,
"route_step_km": 100.0,
"backend": "openap"
}'
import requests
import json
class AerospaceClient:
def __init__(self, base_url="http://localhost:8080"):
self.base_url = base_url
def plan_flight(self, departure, arrival, aircraft="A320", altitude=35000):
"""Plan a flight between two cities."""
response = requests.post(f"{self.base_url}/plan", json={
"depart_city": departure,
"arrive_city": arrival,
"ac_type": aircraft,
"cruise_alt_ft": altitude,
"backend": "openap"
})
return response.json()
def find_airports(self, city, country=None):
"""Find airports in a city."""
params = {"city": city}
if country:
params["country"] = country
response = requests.get(f"{self.base_url}/airports/by_city", params=params)
return response.json()
# Usage
client = AerospaceClient()
# Find airports
airports = client.find_airports("Sydney", "AU")
print(f"Sydney has {len(airports)} airports")
# Plan flight
plan = client.plan_flight("Sydney", "Melbourne", "B737")
print(f"Flight distance: {plan['distance_nm']:.0f} NM")
print(f"Flight time: {plan['estimates']['block']['time_min']:.0f} minutes")
import asyncio
import aiohttp
from typing import List, Dict
async def plan_multiple_flights(flights: List[Dict]) -> List[Dict]:
"""Plan multiple flights concurrently."""
async with aiohttp.ClientSession() as session:
tasks = []
for flight in flights:
task = plan_single_flight(session, flight)
tasks.append(task)
results = await asyncio.gather(*tasks, return_exceptions=True)
return results
async def plan_single_flight(session, flight_data):
"""Plan a single flight."""
async with session.post(
"http://localhost:8080/plan",
json=flight_data
) as response:
return await response.json()
# Example usage
flights_to_plan = [
{"depart_city": "New York", "arrive_city": "London", "ac_type": "A330"},
{"depart_city": "London", "arrive_city": "Dubai", "ac_type": "B777"},
{"depart_city": "Dubai", "arrive_city": "Singapore", "ac_type": "A350"}
]
# Run the batch planning
results = asyncio.run(plan_multiple_flights(flights_to_plan))
for i, result in enumerate(results):
if not isinstance(result, Exception):
print(f"Flight {i+1}: {result['distance_nm']:.0f} NM, {result['estimates']['block']['time_min']:.0f} min")
import requests
class OrbitalMechanicsClient:
def __init__(self, base_url="http://localhost:8080"):
self.base_url = base_url
def plan_hohmann_transfer(self, r1_km, r2_km):
"""Calculate Hohmann transfer between two circular orbits."""
response = requests.post(f"{self.base_url}/hohmann_transfer", json={
"r1_m": r1_km * 1000, # Convert to meters
"r2_m": r2_km * 1000
})
return response.json()
def propagate_satellite_orbit(self, elements, duration_hours):
"""Propagate satellite orbit with J2 perturbations."""
response = requests.post(f"{self.base_url}/propagate_orbit_j2", json={
"initial_state": elements,
"propagation_time_s": duration_hours * 3600,
"time_step_s": 300 # 5-minute steps
})
return response.json()
# Example usage
client = OrbitalMechanicsClient()
# Plan a GTO to GEO transfer
gto_alt = 200 # km (perigee)
geo_alt = 35786 # km (GEO altitude)
transfer = client.plan_hohmann_transfer(
6378 + gto_alt, # Earth radius + altitude
6378 + geo_alt
)
print(f"Transfer Delta-V: {transfer['delta_v_total_ms']/1000:.2f} km/s")
print(f"Transfer Time: {transfer['transfer_time_h']:.1f} hours")
# Propagate ISS orbit for one day
iss_elements = {
"semi_major_axis_m": 6793000, # ~415 km altitude
"eccentricity": 0.0001,
"inclination_deg": 51.6,
"raan_deg": 0.0,
"arg_periapsis_deg": 0.0,
"true_anomaly_deg": 0.0,
"epoch_utc": "2024-01-01T12:00:00"
}
orbit_states = client.propagate_satellite_orbit(iss_elements, 24)
print(f"Propagated {len(orbit_states)} orbital states over 24 hours")
# Optimize a lunar transfer trajectory
def optimize_lunar_transfer():
initial_trajectory = [
{
"time_s": 0,
"position_m": [6700000, 0, 0], # LEO
"velocity_ms": [0, 7500, 0]
},
{
"time_s": 86400 * 3, # 3 days
"position_m": [384400000, 0, 0], # Moon distance
"velocity_ms": [0, 1000, 0]
}
]
response = requests.post("http://localhost:8080/genetic_algorithm_optimization", json={
"initial_trajectory": initial_trajectory,
"objective": "minimize_delta_v",
"constraints": {
"max_thrust_n": 50000,
"max_acceleration_ms2": 10
}
})
result = response.json()
print(f"Optimized Delta-V: {result['total_delta_v_ms']/1000:.2f} km/s")
print(f"Flight Time: {result['flight_time_s']/86400:.1f} days")
return result
optimized_trajectory = optimize_lunar_transfer()
# Generate porkchop plot for Mars mission planning
def plan_mars_mission():
response = requests.post("http://localhost:8080/porkchop_plot_analysis", json={
"departure_body": "Earth",
"arrival_body": "Mars",
"min_tof_days": 200,
"max_tof_days": 300
})
analysis = response.json()
if analysis["summary_statistics"]["feasible_transfers"] > 0:
optimal = analysis["optimal_transfer"]
print(f"Optimal Mars Transfer:")
print(f" Launch: {optimal['departure_date']}")
print(f" Arrival: {optimal['arrival_date']}")
print(f" C3: {optimal['c3_km2_s2']:.2f} km²/s²")
print(f" Flight Time: {optimal['time_of_flight_days']:.0f} days")
else:
print("No feasible transfers found in date range")
plan_mars_mission()
interface FlightPlan {
depart_city: string;
arrive_city: string;
ac_type: string;
cruise_alt_ft?: number;
backend: "openap";
}
class AerospaceAPI {
constructor(private baseUrl: string = "http://localhost:8080") {}
async planFlight(request: FlightPlan) {
const response = await fetch(`${this.baseUrl}/plan`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(request),
});
if (!response.ok) {
throw new Error(`API Error: ${response.statusText}`);
}
return await response.json();
}
async findAirports(city: string, country?: string) {
const params = new URLSearchParams({ city });
if (country) params.append("country", country);
const response = await fetch(`${this.baseUrl}/airports/by_city?${params}`);
return await response.json();
}
}
// Usage
const api = new AerospaceAPI();
try {
const plan = await api.planFlight({
depart_city: "Boston",
arrive_city: "Seattle",
ac_type: "B737",
cruise_alt_ft: 36000,
backend: "openap"
});
console.log(`Flight planned: ${plan.distance_nm} NM`);
console.log(`Estimated time: ${plan.estimates.block.time_min} minutes`);
} catch (error) {
console.error("Flight planning failed:", error);
}
graph TB
Users[Users/Clients] --> API[FastAPI REST API]
Users --> MCP[MCP Server]
API --> Core[Core Services]
MCP --> Core
subgraph "Core Services"
Airport[Airport Resolution]
Route[Route Calculation]
Perf[Performance Estimation]
end
subgraph "Data Sources"
AirportDB[Airport Database<br/>7,861 IATA airports]
OpenAP[OpenAP Models<br/>37 aircraft]
Geodesic[GeographicLib<br/>WGS84 calculations]
end
Airport --> AirportDB
Route --> Geodesic
Perf --> OpenAP
FastAPI Application (main.py)
MCP Server (aerospace_mcp/fastmcp_server.py)
Core Services
Data Layer
Native Core (rust/, imported as aerospace_mcp._native)
This project has been migrated from the traditional MCP SDK to FastMCP, providing significant improvements in developer experience and code maintainability.
FastMCP is a high-level, Pythonic framework for building Model Context Protocol servers. It dramatically reduces boilerplate code while maintaining full MCP compatibility.
✅ 70% Less Code: Tool definitions went from verbose JSON schemas to simple Python decorators ✅ Better Type Safety: Automatic schema generation from type hints ✅ Cleaner Architecture: Modular tool organization across logical domains ✅ Improved Maintainability: Pythonic code that's easier to read and extend ✅ Full Compatibility: Same MCP protocol, works with all existing clients
Before (Traditional MCP SDK):
Tool(
name="search_airports",
description="Search for airports by IATA code or city name",
inputSchema={
"type": "object",
"properties": {
"query": {"type": "string", "description": "IATA code or city name"},
"country": {"type": "string", "description": "Optional country filter"},
"query_type": {"type": "string", "enum": ["iata", "city", "auto"]}
},
"required": ["query"]
}
)
@server.call_tool()
async def handle_call_tool(name: str, arguments: dict):
if name == "search_airports":
return await _handle_search_airports(arguments)
# ... 40+ more tool handlers
After (FastMCP):
@mcp.tool
def search_airports(
query: str,
country: str | None = None,
query_type: Literal["iata", "city", "auto"] = "auto"
) -> str:
"""Search for airports by IATA code or city name."""
# Implementation here
The FastMCP refactoring introduced a modular architecture with tools organized by domain:
tools/core.py - Core flight planning (search, plan, distance, performance)tools/atmosphere.py - Atmospheric modeling and wind analysistools/frames.py - Coordinate frame transformationstools/aerodynamics.py - Wing analysis and airfoil polarstools/propellers.py - Propeller BEMT and UAV energy analysistools/rockets.py - Rocket trajectory and sizingtools/orbits.py - Orbital mechanics and propagationtools/optimization.py - Trajectory optimization algorithmsIntegration modules with NumPy vectorization:
integrations/_array_backend.py - NumPy/CuPy abstraction layer for GPU supportintegrations/atmosphere.py - Vectorized ISA atmosphere calculationsintegrations/aero.py - Vectorized aerodynamics computationsintegrations/rockets.py - Vectorized trajectory integrationintegrations/frames.py - Vectorized coordinate transformationsaerospace_mcp.fastmcp_server:runfastmcp>=2.11.3 instead of raw mcpaerospace-mcp for client compatibilityBoth the HTTP server and MCP servers automatically load environment variables from a local .env (via python-dotenv).
AEROSPACE_MCP_MODE: http or mcp (Docker entrypoint switch)AEROSPACE_MCP_HOST: Bind host for HTTP (default 0.0.0.0)AEROSPACE_MCP_PORT: Port for HTTP (default 8080)AEROSPACE_MCP_LOG_LEVEL: debug|info|warning|error (default info)AEROSPACE_MCP_ENV: development|production (controls reload)LLM_TOOLS_ENABLED: true|false to enable AI agent tools (default false)OPENAI_API_KEY: Required if LLM tools are enabledHTTP API hardening (the FastAPI app in main.py is a thin layer over aerospace_mcp/core.py):
CORS_ORIGINS: Comma-separated list of allowed origins; CORS is disabled when unsetRATE_LIMIT_RPM: Per-IP requests per minute (default 120, 0 disables rate limiting)MAX_BODY_BYTES: Maximum accepted request body size (default 1 MiB)Example .env:
AEROSPACE_MCP_MODE=http
AEROSPACE_MCP_HOST=0.0.0.0
AEROSPACE_MCP_PORT=8080
AEROSPACE_MCP_LOG_LEVEL=debug
LLM_TOOLS_ENABLED=false
# OPENAI_API_KEY=sk-...
route_step_km values for faster processingThe aerospace calculations are optimized using NumPy's vectorized operations, with a drop-in CuPy backend for GPU acceleration on CUDA-capable hardware.
# In your code, before using aerospace functions:
from aerospace_mcp.integrations._array_backend import set_backend, get_backend_info
# Check available backends
print(get_backend_info())
# {'current_backend': 'numpy', 'numpy_available': True, 'cupy_available': True, ...}
# Switch to GPU (requires CuPy and CUDA)
set_backend('cupy')
# Switch back to CPU
set_backend('numpy')
# For CUDA 11.x
pip install cupy-cuda11x
# For CUDA 12.x
pip install cupy-cuda12x
# Auto-detect CUDA version
pip install cupy
The following integration modules support GPU acceleration via the array backend:
Note: GPU acceleration provides the most benefit for batch operations with 1000+ data points. For single calculations, CPU (NumPy) is typically faster due to GPU transfer overhead.
When running the server, comprehensive API documentation is available at:
Health check and system status.
Response:
{
"status": "ok",
"openap": true,
"airports_count": 7861
}
Search airports by city name.
Parameters:
city (required): City name to searchcountry (optional): ISO country code filterExample: GET /airports/by_city?city=London&country=GB
Generate complete flight plan.
Request Body:
{
"depart_city": "San Francisco",
"arrive_city": "New York",
"ac_type": "A320",
"cruise_alt_ft": 37000,
"mass_kg": 65000,
"route_step_km": 25.0,
"backend": "openap"
}
Response: Complete flight plan with route polyline and performance estimates.
All endpoints return standard HTTP status codes:
200: Success400: Bad Request (invalid parameters)404: Not Found (airport/city not found)501: Not Implemented (backend unavailable)Error responses include detailed messages:
{
"detail": "departure: IATA 'XYZ' not found."
}
{
"mcpServers": {
"aerospace": {
"command": "uvx",
"args": ["aerospace-mcp"]
}
}
}
From a source checkout use "command": "uv" with
"args": ["--directory", "/path/to/aerospace-mcp", "run", "aerospace-mcp"].
If Claude Desktop cannot find uvx, give its absolute path (which uvx).
With 47 specialized aerospace tools available (plus 2 discovery tools), the MCP server includes a tool search tool following Anthropic's guide for dynamic tool discovery:
# Search by natural language
search_aerospace_tools("atmospheric pressure altitude")
# Returns: get_atmosphere_profile, wind_model_simple, ...
# Search by regex pattern
search_aerospace_tools("(?i)orbit", search_type="regex")
# Returns: propagate_orbit_j2, elements_to_state_vector, hohmann_transfer, ...
# Filter by category
search_aerospace_tools("calculate", category="orbits")
# Returns only orbital mechanics tools matching "calculate"
# List all categories
list_tool_categories()
# Returns: core, atmosphere, frames, aerodynamics, propellers, rockets, orbits, gnc, performance, optimization, agents
Available categories:
For applications with many tools, aerospace-mcp supports deferred tool loading to keep context windows efficient. When using the Anthropic API with MCP, configure your mcp_toolset to defer loading of all tools except the discovery tools:
{
"tools": [
{
"type": "tool_search_tool_regex_20251119",
"name": "tool_search_tool_regex"
},
{
"type": "mcp_toolset",
"mcp_server_name": "aerospace-mcp",
"default_config": {
"defer_loading": true
},
"configs": {
"search_aerospace_tools": { "defer_loading": false },
"list_tool_categories": { "defer_loading": false }
}
}
]
}
This configuration:
search_aerospace_tools, list_tool_categories)tool_reference blocks from search results into full definitionsWhen Claude needs a specific tool, it uses search_aerospace_tools which returns tool_reference blocks:
{
"tool_references": [
{ "type": "tool_reference", "tool_name": "hohmann_transfer" },
{ "type": "tool_reference", "tool_name": "propagate_orbit_j2" }
]
}
The API automatically expands these references into full tool definitions, keeping context efficient while providing access to all 47 tools.
Add to your config.json:
{
"mcpServers": [
{
"name": "aerospace-mcp",
"command": "uv",
"args": ["run", "aerospace-mcp"],
"workingDirectory": "/path/to/aerospace-mcp"
}
]
}
# Clone and setup
git clone https://github.com/cheesejaguar/aerospace-mcp.git
cd aerospace-mcp
# Create the development environment (needs Rust, see Quick Start)
uv sync
source .venv/bin/activate
# Install pre-commit hooks
pre-commit install
# Run development server
uvicorn main:app --reload --log-level debug
# Run all tests
pytest
# Run with coverage
pytest --cov=. --cov-report=html
# Run specific test file
pytest tests/test_plan.py -v
# Run tool-specific tests
pytest tests/tools/ -v
# Native core unit tests (no Python needed)
cd rust && cargo test --no-default-features
After editing Rust sources, uv sync (or uv run ...) rebuilds the
extension automatically; with a plain pip setup run pip install -e . again.
# Format code
black . && isort .
# Type checking
mypy main.py aerospace_mcp/
# Linting
ruff check .
# Rust formatting and lints
(cd rust && cargo fmt --check && cargo clippy --no-default-features --all-targets -- -D warnings)
# Pre-commit (runs all checks)
pre-commit run --all-files
aerospace-mcp/
├── main.py # FastAPI application
├── aerospace_mcp/ # MCP server implementation
│ ├── __init__.py
│ ├── fastmcp_server.py # FastMCP server entry point
│ ├── core.py # Shared business logic
│ ├── tools/ # MCP tool definitions
│ │ ├── core.py # Flight planning tools
│ │ ├── atmosphere.py # Atmospheric modeling tools
│ │ ├── aerodynamics.py # Wing & airfoil analysis
│ │ ├── frames.py # Coordinate transformations
│ │ ├── rockets.py # Rocket trajectory tools
│ │ ├── orbits.py # Orbital mechanics tools
│ │ ├── propellers.py # Propeller analysis tools
│ │ ├── optimization.py # Trajectory optimization
│ │ ├── gnc.py # GNC tools (Kalman filter, LQR)
│ │ ├── performance.py # Aircraft performance tools
│ │ ├── agents.py # LLM-powered agent tools
│ │ └── tool_search.py # Tool discovery and search
│ └── integrations/ # Backend computation modules
│ ├── _array_backend.py # NumPy/CuPy abstraction (GPU support)
│ ├── atmosphere.py # Vectorized ISA calculations
│ ├── aero.py # Vectorized aerodynamics
│ ├── frames.py # Vectorized coordinate transforms
│ ├── rockets.py # Rocket data model (simulation in rust/)
│ ├── trajopt.py # Trajectory optimization (optimizers in rust/)
│ ├── orbits.py # Orbital mechanics (kernels in rust/)
│ └── propellers.py # Propeller BEMT analysis
├── rust/ # Native core (Rust + PyO3 -> aerospace_mcp._native)
│ ├── Cargo.toml
│ └── src/
│ ├── rocket.rs # 3-DOF ascent simulation & performance metrics
│ ├── optimize.rs # Golden-section, gradient descent, rocket optimizers
│ ├── orbit.rs # Kepler, elements <-> state, J2 RK4, ground track
│ ├── lambert.rs # Izzo Lambert solver
│ └── python.rs # PyO3 bindings
├── app/ # Alternative FastAPI structure
│ ├── __init__.py
│ └── main.py
├── tests/ # Test suite
│ ├── conftest.py
│ ├── test_airports.py
│ ├── test_plan.py
│ ├── test_fastmcp.py
│ ├── test_integrations_*.py # Integration module tests
│ └── tools/ # Tool-specific tests
│ ├── test_tools_performance.py # Performance tools tests
│ ├── test_tools_gnc.py # GNC tools tests
│ └── test_tools_lambert.py # Lambert solver tests
├── docs/ # Documentation
│ ├── API.md
│ ├── ARCHITECTURE.md
│ ├── INTEGRATION.md
│ ├── QUICKSTART.md
│ ├── DEPLOYMENT.md
│ └── MCP_INTEGRATION.md
├── pyproject.toml # Project configuration
├── requirements.txt # Dependencies
├── Dockerfile # Docker configuration
├── docker-compose.yml # Multi-service setup
└── README.md # This file
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
Fork & Clone
git clone https://github.com/yourusername/aerospace-mcp.git
cd aerospace-mcp
Setup Development Environment
uv sync && source .venv/bin/activate
Make Changes
Test & Format
pytest
black . && isort .
mypy main.py
Submit Pull Request
plan_multi_leg_flight)This project is licensed under the MIT License - see the LICENSE file for details.
/docsFor enterprise support, consulting, or custom development:
⭐ Star this repository if you find it useful!
Built with ❤️ for the aviation and software development communities.
MCP server for generic aviation and space information
Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
No required environment variable is listed on this record.
Aerospace runs locally over stdio.
Last checked 2026-10-28. MCP server for generic aviation and space information