Update rebound/mcp_output/mcp_plugin/mcp_service.py

rebound/mcp_output/mcp_plugin/mcp_service.py

@@ -1,138 +1,1137 @@
+import os
+import sys
+
+# Add the local source directory to sys.path
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
 from fastmcp import FastMCP
+import json
+import math
+
+# Check if rebound is available
+try:
+    import rebound
+    from rebound import tools, data
+    REBOUND_AVAILABLE = True
+except ImportError:
+    REBOUND_AVAILABLE = False
 
 # Create the FastMCP service application
 mcp = FastMCP("rebound_service")
 
-@mcp.tool(name="initialize_simulation", description="Initialize a REBOUND simulation")
-def initialize_simulation(particles: list, integrator: str = "ias15") -> dict:
+# Store simulations in memory (keyed by simulation ID)
+_simulations = {}
+_sim_counter = 0
+
+# ============================================================================
+# Core Simulation Tools
+# ============================================================================
+
+@mcp.tool()
+def create_simulation(integrator: str = "ias15", dt: float = 0.01, 
+                     gravity: str = "compensated", collision: str = "none",
+                     boundary: str = "none", G: float = 1.0) -> dict:
     """
-    Initialize a REBOUND simulation with particles and an integrator.
+    Create a new N-body simulation instance.
 
     Parameters:
-    - particles: A list of particle dictionaries with mass, position, and velocity.
-    - integrator: The integrator to use (default: "ias15").
+    - integrator: Integrator ('ias15', 'whfast', 'mercurius', 'leapfrog', 'sei', 'eos', 'bs', 'janus', 'trace')
+    - dt: Timestep for fixed timestep integrators
+    - gravity: Gravity solver ('compensated', 'basic', 'none', 'tree')
+    - collision: Collision detection ('none', 'direct', 'tree')
+    - boundary: Boundary conditions ('none', 'open', 'periodic', 'shear')
+    - G: Gravitational constant (default 1.0)
 
     Returns:
-    - dict: Simulation object and status.
+    - dict: Simulation ID and configuration
     """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
     try:
-        import rebound
-        
+        global _sim_counter
         sim = rebound.Simulation()
         sim.integrator = integrator
-        for p in particles:
-            sim.add(m=p['mass'], x=p['x'], y=p['y'], z=p['z'], vx=p['vx'], vy=p['vy'], vz=p['vz'])
+        sim.dt = dt
+        sim.gravity = gravity
+        sim.collision = collision
+        sim.boundary = boundary
+        sim.G = G
+        
+        sim_id = f"sim_{_sim_counter}"
+        _simulations[sim_id] = sim
+        _sim_counter += 1
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "integrator": integrator,
+            "dt": dt,
+            "gravity": gravity,
+            "collision": collision,
+            "boundary": boundary,
+            "G": G,
+            "n_particles": sim.N
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def add_particle(sim_id: str, m: float = 0.0, x: float = 0.0, y: float = 0.0, z: float = 0.0,
+                vx: float = 0.0, vy: float = 0.0, vz: float = 0.0, r: float = 0.0,
+                hash_value: str = "") -> dict:
+    """
+    Add a particle using Cartesian coordinates.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - m: Mass
+    - x, y, z: Position
+    - vx, vy, vz: Velocity
+    - r: Particle radius (for collision detection)
+    - hash_value: Optional hash identifier for particle
+
+    Returns:
+    - dict: Particle info
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        
+        if hash_value:
+            sim.add(m=m, x=x, y=y, z=z, vx=vx, vy=vy, vz=vz, r=r, hash=hash_value)
+        else:
+            sim.add(m=m, x=x, y=y, z=z, vx=vx, vy=vy, vz=vz, r=r)
+        
+        particle_idx = sim.N - 1
+        p = sim.particles[particle_idx]
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "n_particles": sim.N,
+            "particle_index": particle_idx,
+            "particle": {
+                "m": p.m, "r": p.r,
+                "x": p.x, "y": p.y, "z": p.z,
+                "vx": p.vx, "vy": p.vy, "vz": p.vz,
+                "hash": str(p.hash)
+            }
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def add_particle_with_orbital_elements(sim_id: str, primary_index: int = 0,
+                                       m: float = 0.0, a: float = 1.0, e: float = 0.0,
+                                       inc: float = 0.0, Omega: float = 0.0,
+                                       omega: float = 0.0, f: float = 0.0, r: float = 0.0) -> dict:
+    """
+    Add a particle using orbital elements relative to a primary body.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - primary_index: Index of primary body (usually 0 for central star)
+    - m: Mass
+    - a: Semi-major axis
+    - e: Eccentricity
+    - inc: Inclination (radians)
+    - Omega: Longitude of ascending node (radians)
+    - omega: Argument of periapsis (radians)
+    - f: True anomaly (radians)
+    - r: Particle radius
+
+    Returns:
+    - dict: Particle info
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        
+        if primary_index >= sim.N:
+            return {"success": False, "error": f"Primary index {primary_index} out of range"}
+        
+        primary = sim.particles[primary_index]
+        sim.add(m=m, a=a, e=e, inc=inc, Omega=Omega, omega=omega, f=f, r=r, primary=primary)
+        
+        particle_idx = sim.N - 1
+        p = sim.particles[particle_idx]
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "n_particles": sim.N,
+            "particle_index": particle_idx,
+            "particle": {
+                "m": p.m, "r": p.r,
+                "x": p.x, "y": p.y, "z": p.z,
+                "vx": p.vx, "vy": p.vy, "vz": p.vz
+            }
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def integrate(sim_id: str, tmax: float, exact_finish_time: bool = True) -> dict:
+    """
+    Integrate the simulation forward in time.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - tmax: Time to integrate to
+    - exact_finish_time: Whether to finish exactly at tmax
+
+    Returns:
+    - dict: Simulation state after integration
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        sim.integrate(tmax, exact_finish_time=1 if exact_finish_time else 0)
+        
+        particles = []
+        for i, p in enumerate(sim.particles):
+            particles.append({
+                "index": i,
+                "m": p.m,
+                "x": p.x, "y": p.y, "z": p.z,
+                "vx": p.vx, "vy": p.vy, "vz": p.vz
+            })
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "t": sim.t,
+            "dt": sim.dt,
+            "n_particles": sim.N,
+            "particles": particles
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def step(sim_id: str) -> dict:
+    """
+    Perform a single integration step.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: Simulation state after step
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        sim.step()
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "t": sim.t,
+            "dt": sim.dt,
+            "n_particles": sim.N
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def remove_particle(sim_id: str, index: int = 0, keep_sorted: bool = True) -> dict:
+    """
+    Remove a particle from the simulation.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - index: Particle index to remove
+    - keep_sorted: Whether to keep particle array sorted
+
+    Returns:
+    - dict: Updated simulation state
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        
+        if index >= sim.N:
+            return {"success": False, "error": f"Particle index {index} out of range"}
+        
+        sim.remove(index=index, keep_sorted=keep_sorted)
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "n_particles": sim.N,
+            "message": f"Particle {index} removed"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_particles(sim_id: str) -> dict:
+    """
+    Get all particles in the simulation.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: List of all particles with full state information
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        
+        particles = []
+        for i, p in enumerate(sim.particles):
+            particles.append({
+                "index": i,
+                "hash": str(p.hash),
+                "m": p.m,
+                "r": p.r,
+                "x": p.x, "y": p.y, "z": p.z,
+                "vx": p.vx, "vy": p.vy, "vz": p.vz,
+                "ax": p.ax, "ay": p.ay, "az": p.az,
+                "last_collision": p.last_collision
+            })
         
         return {
             "success": True,
-            "simulation": sim.serialize()
+            "sim_id": sim_id,
+            "t": sim.t,
+            "n_particles": sim.N,
+            "n_active": sim.N_active,
+            "particles": particles
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="integrate_simulation", description="Integrate a REBOUND simulation")
-def integrate_simulation(simulation: dict, time: float) -> dict:
+
+@mcp.tool()
+def get_orbital_elements(sim_id: str, particle_index: int, primary_index: int = 0) -> dict:
     """
-    Integrate a REBOUND simulation to a specific time.
+    Calculate orbital elements for a particle.
 
     Parameters:
-    - simulation: Serialized REBOUND simulation object.
-    - time: Time to integrate the simulation to.
+    - sim_id: Simulation ID
+    - particle_index: Index of particle
+    - primary_index: Index of primary body (default 0)
 
     Returns:
-    - dict: Updated simulation state.
+    - dict: Orbital elements
     """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
     try:
-        import rebound
+        sim = _simulations[sim_id]
         
-        sim = rebound.Simulation.deserialize(simulation)
-        sim.integrate(time)
+        if particle_index >= sim.N or primary_index >= sim.N:
+            return {"success": False, "error": "Particle index out of range"}
+        
+        orbit = sim.particles[particle_index].calculate_orbit(primary=sim.particles[primary_index])
         
         return {
             "success": True,
-            "simulation": sim.serialize()
+            "sim_id": sim_id,
+            "particle_index": particle_index,
+            "primary_index": primary_index,
+            "t": sim.t,
+            "orbital_elements": {
+                "a": orbit.a,              # Semi-major axis
+                "e": orbit.e,              # Eccentricity
+                "inc": orbit.inc,          # Inclination
+                "Omega": orbit.Omega,      # Longitude of ascending node
+                "omega": orbit.omega,      # Argument of periapsis
+                "f": orbit.f,              # True anomaly
+                "M": orbit.M,              # Mean anomaly
+                "l": orbit.l,              # Mean longitude
+                "theta": orbit.theta,      # True longitude
+                "T": orbit.T,              # Periapsis time
+                "n": orbit.n,              # Mean motion
+                "P": orbit.P,              # Orbital period
+                "rp": orbit.rp,            # Periapsis distance
+                "ap": getattr(orbit, 'ap', None)  # Apoapsis distance
+            }
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="add_particle", description="Add a particle to a REBOUND simulation")
-def add_particle(simulation: dict, particle: dict) -> dict:
+
+@mcp.tool()
+def calculate_energy(sim_id: str) -> dict:
     """
-    Add a particle to a REBOUND simulation.
+    Calculate total energy of the system.
 
     Parameters:
-    - simulation: Serialized REBOUND simulation object.
-    - particle: A dictionary with mass, position, and velocity of the particle.
+    - sim_id: Simulation ID
 
     Returns:
-    - dict: Updated simulation state.
+    - dict: Total energy
     """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
     try:
-        import rebound
+        sim = _simulations[sim_id]
+        energy = sim.calculate_energy()
         
-        sim = rebound.Simulation.deserialize(simulation)
-        sim.add(m=particle['mass'], x=particle['x'], y=particle['y'], z=particle['z'], vx=particle['vx'], vy=particle['vy'], vz=particle['vz'])
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "total_energy": energy,
+            "t": sim.t
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def calculate_angular_momentum(sim_id: str) -> dict:
+    """
+    Calculate total angular momentum of the system.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: Angular momentum vector
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        L = sim.calculate_angular_momentum()
         
         return {
             "success": True,
-            "simulation": sim.serialize()
+            "sim_id": sim_id,
+            "angular_momentum": {
+                "x": L[0],
+                "y": L[1],
+                "z": L[2]
+            },
+            "magnitude": math.sqrt(L[0]**2 + L[1]**2 + L[2]**2),
+            "t": sim.t
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="analyze_orbital_elements", description="Analyze orbital elements of particles in a REBOUND simulation")
-def analyze_orbital_elements(simulation: dict) -> dict:
+
+@mcp.tool()
+def calculate_com(sim_id: str) -> dict:
     """
-    Analyze the orbital elements of particles in a REBOUND simulation.
+    Calculate center of mass position and velocity.
 
     Parameters:
-    - simulation: Serialized REBOUND simulation object.
+    - sim_id: Simulation ID
 
     Returns:
-    - dict: Orbital elements of particles.
+    - dict: Center of mass coordinates
     """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
     try:
-        import rebound
+        sim = _simulations[sim_id]
+        com = sim.calculate_com()
         
-        sim = rebound.Simulation.deserialize(simulation)
-        elements = [sim.particles[i].calculate_orbit() for i in range(len(sim.particles))]
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "com": {
+                "x": com.x, "y": com.y, "z": com.z,
+                "vx": com.vx, "vy": com.vy, "vz": com.vz
+            }
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def move_to_com(sim_id: str) -> dict:
+    """
+    Move simulation to center of mass frame.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: Confirmation
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        sim.move_to_com()
         
         return {
             "success": True,
-            "orbital_elements": [e.__dict__ for e in elements]
+            "sim_id": sim_id,
+            "message": "Simulation moved to center of mass frame"
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="visualize_simulation", description="Visualize a REBOUND simulation")
-def visualize_simulation(simulation: dict) -> dict:
+
+@mcp.tool()
+def calculate_megno(sim_id: str, tmax: float) -> dict:
     """
-    Visualize a REBOUND simulation.
+    Calculate MEGNO (Mean Exponential Growth factor of Nearby Orbits) chaos indicator.
 
     Parameters:
-    - simulation: Serialized REBOUND simulation object.
+    - sim_id: Simulation ID
+    - tmax: Time to integrate
 
     Returns:
-    - dict: Visualization status.
+    - dict: MEGNO value
     """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
     try:
-        import rebound
+        sim = _simulations[sim_id]
         
-        sim = rebound.Simulation.deserialize(simulation)
-        sim.display()
+        # Initialize variational particles
+        sim.init_megno()
+        sim.integrate(tmax)
+        megno = sim.calculate_megno()
         
         return {
             "success": True,
-            "message": "Simulation visualization displayed successfully."
+            "sim_id": sim_id,
+            "megno": megno,
+            "t": sim.t,
+            "interpretation": "MEGNO < 2: Regular/Quasi-periodic, MEGNO > 2: Chaotic"
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
+
+@mcp.tool()
+def calculate_lyapunov(sim_id: str, tmax: float) -> dict:
+    """
+    Calculate maximum Lyapunov characteristic exponent.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - tmax: Time to integrate
+
+    Returns:
+    - dict: Lyapunov exponent
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        
+        # Initialize variational particles
+        sim.init_megno()
+        sim.integrate(tmax)
+        lyapunov = sim.calculate_lyapunov()
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "lyapunov_exponent": lyapunov,
+            "lyapunov_timescale": 1.0/lyapunov if lyapunov > 0 else float('inf'),
+            "t": sim.t
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ============================================================================
+# Coordinate Transformation Tools
+# ============================================================================
+
+@mcp.tool()
+def spherical_to_cartesian(magnitude: float = 1.0, theta: float = 0.0, phi: float = 0.0) -> dict:
+    """
+    Convert spherical coordinates to Cartesian.
+
+    Parameters:
+    - magnitude: Vector magnitude
+    - theta: Polar angle (radians, measured from z-axis)
+    - phi: Azimuthal angle (radians, measured from x-axis)
+
+    Returns:
+    - dict: Cartesian coordinates
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        vec = tools.spherical_to_xyz(magnitude=magnitude, theta=theta, phi=phi)
+        
+        return {
+            "success": True,
+            "cartesian": {
+                "x": vec.x,
+                "y": vec.y,
+                "z": vec.z
+            },
+            "input": {
+                "magnitude": magnitude,
+                "theta": theta,
+                "phi": phi
+            }
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def cartesian_to_spherical(x: float, y: float, z: float) -> dict:
+    """
+    Convert Cartesian coordinates to spherical.
+
+    Parameters:
+    - x, y, z: Cartesian coordinates
+
+    Returns:
+    - dict: Spherical coordinates
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        magnitude, theta, phi = tools.xyz_to_spherical([x, y, z])
+        
+        return {
+            "success": True,
+            "spherical": {
+                "magnitude": magnitude,
+                "theta": theta,
+                "phi": phi
+            },
+            "input": {
+                "x": x,
+                "y": y,
+                "z": z
+            }
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def mean_anomaly_to_true_anomaly(e: float, M: float) -> dict:
+    """
+    Convert mean anomaly to true anomaly.
+
+    Parameters:
+    - e: Eccentricity
+    - M: Mean anomaly (radians)
+
+    Returns:
+    - dict: True anomaly
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        f = tools.M_to_f(e, M)
+        
+        return {
+            "success": True,
+            "true_anomaly": f,
+            "eccentricity": e,
+            "mean_anomaly": M
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def eccentric_anomaly_to_true_anomaly(e: float, E: float) -> dict:
+    """
+    Convert eccentric anomaly to true anomaly.
+
+    Parameters:
+    - e: Eccentricity
+    - E: Eccentric anomaly (radians)
+
+    Returns:
+    - dict: True anomaly
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        f = tools.E_to_f(e, E)
+        
+        return {
+            "success": True,
+            "true_anomaly": f,
+            "eccentricity": e,
+            "eccentric_anomaly": E
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def mean_anomaly_to_eccentric_anomaly(e: float, M: float) -> dict:
+    """
+    Convert mean anomaly to eccentric anomaly.
+
+    Parameters:
+    - e: Eccentricity
+    - M: Mean anomaly (radians)
+
+    Returns:
+    - dict: Eccentric anomaly
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        E = tools.M_to_E(e, M)
+        
+        return {
+            "success": True,
+            "eccentric_anomaly": E,
+            "eccentricity": e,
+            "mean_anomaly": M
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ============================================================================
+# Preset Systems and Initial Conditions
+# ============================================================================
+
+@mcp.tool()
+def add_outer_solar_system(sim_id: str) -> dict:
+    """
+    Add outer Solar System (Jupiter, Saturn, Uranus, Neptune, Pluto) from NASA Horizons data.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: System information
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        data.add_outer_solar_system(sim)
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "n_particles": sim.N,
+            "bodies": ["Sun", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto"],
+            "message": "Outer Solar System added"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def add_full_solar_system(sim_id: str) -> dict:
+    """
+    Add all planets of the Solar System from NASA Horizons data.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: System information
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        data.add_solar_system(sim)
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "n_particles": sim.N,
+            "bodies": ["Sun", "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"],
+            "message": "Full Solar System added"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def add_horizons_body(sim_id: str, body_name: str, date: str = "2024-01-01") -> dict:
+    """
+    Add a celestial body from NASA Horizons database.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - body_name: Name of body (e.g., 'Sun', 'Earth', 'Mars', 'Jupiter')
+    - date: Date for initial conditions (YYYY-MM-DD format)
+
+    Returns:
+    - dict: Body information
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        sim.add(body_name, date=date)
+        
+        particle_idx = sim.N - 1
+        p = sim.particles[particle_idx]
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "body_name": body_name,
+            "date": date,
+            "n_particles": sim.N,
+            "particle": {
+                "index": particle_idx,
+                "m": p.m,
+                "x": p.x, "y": p.y, "z": p.z,
+                "vx": p.vx, "vy": p.vy, "vz": p.vz
+            }
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ============================================================================
+# File I/O Tools
+# ============================================================================
+
+@mcp.tool()
+def save_simulation(sim_id: str, filename: str) -> dict:
+    """
+    Save simulation to a binary file.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - filename: Output filename
+
+    Returns:
+    - dict: Confirmation
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        sim.save_to_file(filename)
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "filename": filename,
+            "message": "Simulation saved"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def load_simulation(filename: str) -> dict:
+    """
+    Load simulation from a binary file.
+
+    Parameters:
+    - filename: Input filename
+
+    Returns:
+    - dict: New simulation ID
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        global _sim_counter
+        sim = rebound.Simulation(filename)
+        
+        sim_id = f"sim_{_sim_counter}"
+        _simulations[sim_id] = sim
+        _sim_counter += 1
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "filename": filename,
+            "t": sim.t,
+            "n_particles": sim.N,
+            "integrator": sim.integrator,
+            "message": "Simulation loaded"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+
+
+# ============================================================================
+# Configuration and Management Tools
+# ============================================================================
+
+@mcp.tool()
+def set_integrator_options(sim_id: str, option_name: str, option_value: float) -> dict:
+    """
+    Set integrator-specific options.
+
+    Parameters:
+    - sim_id: Simulation ID
+    - option_name: Option name (e.g., 'epsilon' for IAS15, 'safe_mode' for WHFast)
+    - option_value: Option value
+
+    Returns:
+    - dict: Confirmation
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        setattr(sim.ri, option_name, option_value)
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "option_name": option_name,
+            "option_value": option_value
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_simulation_status(sim_id: str) -> dict:
+    """
+    Get current simulation status and configuration.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: Simulation configuration and status
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        sim = _simulations[sim_id]
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "t": sim.t,
+            "dt": sim.dt,
+            "dt_last_done": sim.dt_last_done,
+            "n_particles": sim.N,
+            "n_active": sim.N_active,
+            "integrator": sim.integrator,
+            "gravity": sim.gravity,
+            "collision": sim.collision,
+            "boundary": sim.boundary,
+            "G": sim.G,
+            "softening": sim.softening,
+            "testparticle_type": sim.testparticle_type,
+            "walltime": sim.walltime
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def list_active_simulations() -> dict:
+    """
+    List all active simulation IDs.
+
+    Returns:
+    - dict: List of simulation IDs
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    try:
+        sim_list = []
+        for sim_id, sim in _simulations.items():
+            sim_list.append({
+                "sim_id": sim_id,
+                "t": sim.t,
+                "n_particles": sim.N,
+                "integrator": sim.integrator
+            })
+        
+        return {
+            "success": True,
+            "n_simulations": len(sim_list),
+            "simulations": sim_list
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def delete_simulation(sim_id: str) -> dict:
+    """
+    Delete a simulation from memory.
+
+    Parameters:
+    - sim_id: Simulation ID
+
+    Returns:
+    - dict: Confirmation
+    """
+    if not REBOUND_AVAILABLE:
+        return {"success": False, "error": "REBOUND not installed"}
+    
+    if sim_id not in _simulations:
+        return {"success": False, "error": f"Simulation {sim_id} not found"}
+    
+    try:
+        del _simulations[sim_id]
+        
+        return {
+            "success": True,
+            "sim_id": sim_id,
+            "message": "Simulation deleted"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool()
+def get_rebound_info() -> dict:
+    """
+    Get REBOUND version and available features.
+
+    Returns:
+    - dict: Version and features
+    """
+    if not REBOUND_AVAILABLE:
+        return {
+            "success": False,
+            "available": False,
+            "message": "REBOUND not installed. Install with: pip install rebound"
+        }
+    
+    try:
+        return {
+            "success": True,
+            "available": True,
+            "version": rebound.__version__,
+            "build": rebound.__build__,
+            "githash": rebound.__githash__,
+            "description": "Open-source multi-purpose N-body code for collisional dynamics",
+            "integrators": ["IAS15", "WHFast", "Mercurius", "LeapFrog", "SEI", "EOS", "BS", "JANUS", "TRACE"],
+            "gravity_solvers": ["compensated", "basic", "none", "tree"],
+            "collision_detection": ["none", "direct", "tree"],
+            "boundary_conditions": ["none", "open", "periodic", "shear"],
+            "features": [
+                "N-body gravity",
+                "Collisional dynamics",
+                "Orbital elements",
+                "Variational equations",
+                "MEGNO chaos indicator",
+                "SimulationArchive",
+                "NASA Horizons integration"
+            ],
+            "website": "https://rebound.readthedocs.io/",
+            "github": "https://github.com/hannorein/rebound"
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
 def create_app() -> FastMCP:
     """
-    Create and return the FastMCP application instance.
+    Creates and returns the FastMCP application instance.
 
     Returns:
-    - FastMCP: The FastMCP application instance.
+        FastMCP: The FastMCP application instance.
     """
-    return mcp
+    return mcp
+
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=8000)