Update pyPDAF/mcp_output/mcp_plugin/mcp_service.py

pyPDAF/mcp_output/mcp_plugin/mcp_service.py

@@ -1,1741 +1,606 @@
 """
-MCP Service for pyPDAF - Parallel Data Assimilation Framework
+MCP Server for Ocean Data Assimilation using pyPDAF EnOI
 
-This module provides MCP (Model Context Protocol) tools for interacting with
-the pyPDAF library, which is a Python interface to the PDAF (Parallel Data
-Assimilation Framework) library for ensemble-based data assimilation.
+This module provides two MCP tools:
+1. generate_demo_ocean_data: Generate synthetic ocean data (restart, ensemble, observations)
+2. run_enoi_pipeline: Run EnOI data assimilation with optional localization
 """
 
-import os
 import sys
-from typing import List, Optional
+import os
+# Add source path to import pyPDAF
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../source/src'))
 
 import numpy as np
-
-source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
-sys.path.insert(0, source_path)
-
+import netCDF4 as nc
 from fastmcp import FastMCP
-from src.pyPDAF import PDAF, PDAF3, PDAFlocal, PDAFlocalomi, PDAFomi
+from typing import Dict, Any, Tuple
+import glob
 
-mcp = FastMCP("pyPDAF_service")
+try:
+    import pyPDAF
+    import pyPDAF.PDAF as PDAF
+    import pyPDAF.PDAFomi as PDAFomi
+    PYPDAF_AVAILABLE = True
+except ImportError:
+    PYPDAF_AVAILABLE = False
+    print("Warning: pyPDAF not available, run_enoi_pipeline will not work")
+
+# Initialize FastMCP server
+mcp = FastMCP("pyPDAF MCP Server")
 
 
 # ============================================================================
-# PDAF Core Module Tools
+# Helper Functions
 # ============================================================================
 
-@mcp.tool(name="pdaf_gather_dim_obs_f", description="Gather global observation dimension across local domains")
-def pdaf_gather_dim_obs_f(dim_obs_p: int) -> dict:
-    """
-    Gather total observation dimension and displacements from local dimensions.
-
-    This allocates the global observation size used by gather_obs_f routines.
-
-    Args:
-        dim_obs_p: Process-local observation dimension.
-
-    Returns:
-        dict: A dictionary containing the full observation dimension.
-    """
-    try:
-        dim_obs_f = PDAF.gather_dim_obs_f(dim_obs_p)
-        return {"success": True, "result": {"dim_obs_f": int(dim_obs_f)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_gather_obs_f", description="Gather full observation vector from process-local pieces")
-def pdaf_gather_obs_f(obs_p: List[float], dimobs_f: int) -> dict:
-    """
-    Concatenate process-local observation vectors into a full vector (local-filter use).
-
-    Args:
-        obs_p: Process-local observation vector.
-        dimobs_f: Full observation dimension.
-
-    Returns:
-        dict: A dictionary containing the gathered observation vector and status.
-    """
-    try:
-        obs_p_np = np.array(obs_p, dtype=np.float64)
-        obs_f, status = PDAF.gather_obs_f(obs_p_np, dimobs_f)
-        return {
-            "success": True,
-            "result": {"obs_f": obs_f.tolist(), "status": int(status)},
-            "error": None,
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_gather_obs_f2", description="Gather observation coordinates from local pieces")
-def pdaf_gather_obs_f2(coords_p: List[List[float]], nrows: int, dimobs_f: int) -> dict:
-    """
-    Concatenate process-local observation coordinate arrays into a full coordinate array.
-
-    Args:
-        coords_p: Local coordinate array shaped [nrows, dimobs_p].
-        nrows: Number of coordinate rows (e.g., spatial dimensions).
-        dimobs_f: Full observation dimension.
-
-    Returns:
-        dict: A dictionary containing the gathered coordinates and status.
-    """
-    try:
-        coords_p_np = np.array(coords_p, dtype=np.float64)
-        coords_f, status = PDAF.gather_obs_f2(coords_p_np, nrows, dimobs_f)
-        return {
-            "success": True,
-            "result": {"coords_f": coords_f.tolist(), "status": int(status)},
-            "error": None,
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_gather_obs_f_flex", description="Gather full observation vector without PDAF-internal metadata")
-def pdaf_gather_obs_f_flex(dim_obs_p: int, dim_obs_f: int, obs_p: List[float]) -> dict:
-    """
-    Flexibly gather observation vectors using explicit local/global sizes.
-
-    Args:
-        dim_obs_p: Process-local observation dimension.
-        dim_obs_f: Full observation dimension.
-        obs_p: Local observation vector.
-
-    Returns:
-        dict: A dictionary containing the gathered observation vector and status.
-    """
-    try:
-        obs_p_np = np.array(obs_p, dtype=np.float64)
-        obs_f, status = PDAF.gather_obs_f_flex(dim_obs_p, dim_obs_f, obs_p_np)
-        return {
-            "success": True,
-            "result": {"obs_f": obs_f.tolist(), "status": int(status)},
-            "error": None,
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_gather_obs_f2_flex", description="Gather observation coordinates without PDAF-internal metadata")
-def pdaf_gather_obs_f2_flex(dim_obs_p: int, dim_obs_f: int, coords_p: List[List[float]], nrows: int) -> dict:
-    """
-    Flexibly gather 2D observation coordinate arrays using explicit local/global sizes.
-
-    Args:
-        dim_obs_p: Process-local observation dimension.
-        dim_obs_f: Full observation dimension.
-        coords_p: Local coordinate array shaped [nrows, dim_obs_p].
-        nrows: Number of coordinate rows (e.g., spatial dimensions).
-
-    Returns:
-        dict: A dictionary containing the gathered coordinates and status.
-    """
-    try:
-        coords_p_np = np.array(coords_p, dtype=np.float64)
-        coords_f, status = PDAF.gather_obs_f2_flex(dim_obs_p, dim_obs_f, coords_p_np, nrows)
-        return {
-            "success": True,
-            "result": {"coords_f": coords_f.tolist(), "status": int(status)},
-            "error": None,
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="pdaf_correlation_function", description="Calculate the value of a correlation function at a given distance")
-def pdaf_correlation_function(ctype: int, length: float, distance: float) -> dict:
-    """
-    Calculate the value of the chosen correlation function according to the specified length scale.
-    
-    Args:
-        ctype: Type of correlation function
-               1: Gaussian with f(0)=1.0
-               2: 5th-order polynomial (Gaspari/Cohn, 1999)
-        length: Length scale of function
-                ctype=1: standard deviation
-                ctype=2: support length (f=0 for distance>length)
-        distance: Distance at which the function is evaluated
-    
-    Returns:
-        dict: A dictionary containing the success status and the correlation value.
-    """
-    try:
-        value = PDAF.correlation_function(ctype, length, distance)
-        return {"success": True, "result": {"value": float(value)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_deallocate", description="Finalize the PDAF system and free allocated memory")
-def pdaf_deallocate() -> dict:
-    """
-    Finalise the PDAF system including freeing some of the memory used by PDAF.
-    
-    Note: This function cannot free all allocated PDAF memory.
-    Therefore, one should not use PDAF.init afterwards.
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.deallocate()
-        return {"success": True, "result": "PDAF memory deallocated successfully", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_eofcovar", description="Perform EOF analysis of an ensemble of state vectors by SVD")
-def pdaf_eofcovar(
-    dim: int,
-    nstates: int,
-    nfields: int,
-    dim_fields: List[int],
-    offsets: List[int],
-    remove_mstate: int,
-    do_mv: int,
-    states: List[List[float]],
-    meanstate: List[float],
-    verbose: int
-) -> dict:
-    """
-    EOF analysis of an ensemble of state vectors by singular value decomposition.
-    
-    This function performs a singular value decomposition of the ensemble anomaly.
-    The singular values and corresponding singular vectors can be used to
-    construct a covariance matrix for the initial ensemble.
-    
-    Args:
-        dim: Dimension of state vector
-        nstates: Number of state vectors
-        nfields: Number of fields in state vector
-        dim_fields: Size of each field (list of length nfields)
-        offsets: Start position of each field (list of length nfields)
-        remove_mstate: 1 to subtract mean state from states
-        do_mv: 1 for multivariate scaling; 0 for no scaling
-        states: State perturbations (2D list of shape [dim, nstates])
-        meanstate: Mean state (list of length dim)
-        verbose: Verbosity flag
-    
-    Returns:
-        dict: A dictionary containing:
-            - states: Updated state perturbations
-            - stddev: Standard deviation of field variability
-            - svals: Singular values divided by sqrt(nstates-1)
-            - svec: Singular vectors
-            - meanstate: Updated mean state
-            - status: Status flag
-    """
-    try:
-        states_np = np.array(states, dtype=np.float64)
-        meanstate_np = np.array(meanstate, dtype=np.float64)
-        dim_fields_np = np.array(dim_fields, dtype=np.int32)
-        offsets_np = np.array(offsets, dtype=np.int32)
+def _write_model_nc(filepath: str, lon: np.ndarray, lat: np.ndarray, depth: np.ndarray,
+                    temp: np.ndarray, salt: np.ndarray, u: np.ndarray, v: np.ndarray, eta_t: np.ndarray):
+    """Write ocean model data to NetCDF file."""
+    with nc.Dataset(filepath, 'w') as ds:
+        # Create dimensions
+        ds.createDimension('lon', len(lon))
+        ds.createDimension('lat', len(lat))
+        ds.createDimension('depth', len(depth))
+        ds.createDimension('time', None)
         
-        result = PDAF.eofcovar(
-            dim, nstates, nfields, dim_fields_np, offsets_np,
-            remove_mstate, do_mv, states_np, meanstate_np, verbose
-        )
+        # Create coordinate variables
+        lon_var = ds.createVariable('lon', 'f4', ('lon',))
+        lon_var[:] = lon
+        lon_var.units = 'degrees_east'
         
-        states_out, stddev, svals, svec, meanstate_out, status = result
-        return {
-            "success": True,
-            "result": {
-                "states": states_out.tolist(),
-                "stddev": stddev.tolist(),
-                "svals": svals.tolist(),
-                "svec": svec.tolist(),
-                "meanstate": meanstate_out.tolist(),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_force_analysis", description="Force PDAF to perform analysis at next assimilation call")
-def pdaf_force_analysis() -> dict:
-    """
-    Force PDAF to perform assimilation at the next function call.
-    
-    This function overwrites member index of the ensemble state
-    and forces that the analysis step is executed at the next call
-    to PDAF assimilation functions.
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.force_analysis()
-        return {"success": True, "result": "Analysis forced successfully", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_get_fcst_info", description="Get forecast information including time steps and exit flag")
-def pdaf_get_fcst_info(steps: int = 0, time: float = 0.0, doexit: int = 0) -> dict:
-    """
-    Return the number of time steps, current model time, and exit flag.
-    
-    This is used when the flexible parallelization mode is used with
-    PDAF3.assimilate. This is also relevant for legacy assimilation functions.
-    
-    Args:
-        steps: Number of forecast time steps (input can be arbitrary)
-        time: Current model time
-        doexit: Whether to exit from forecasts
-    
-    Returns:
-        dict: A dictionary containing:
-            - steps: Number of forecast time steps for next assimilation
-            - time: Current model time
-            - doexit: Whether to exit from forecasts
-    """
-    try:
-        steps_out, time_out, doexit_out = PDAF.get_fcst_info(steps, time, doexit)
-        return {
-            "success": True,
-            "result": {
-                "steps": int(steps_out),
-                "time": float(time_out),
-                "doexit": int(doexit_out)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_print_filter_types", description="Print available filter types in PDAF")
-def pdaf_print_filter_types(verbose: int = 1) -> dict:
-    """
-    Print all available filter types in PDAF to the console.
-    
-    Args:
-        verbose: Verbosity flag. If 0, no output; if > 0, prints list to stdout.
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.print_filter_types(verbose)
-        return {"success": True, "result": "Filter types printed to console", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        lat_var = ds.createVariable('lat', 'f4', ('lat',))
+        lat_var[:] = lat
+        lat_var.units = 'degrees_north'
+        
+        depth_var = ds.createVariable('depth', 'f4', ('depth',))
+        depth_var[:] = depth
+        depth_var.units = 'meters'
+        
+        time_var = ds.createVariable('time', 'f4', ('time',))
+        time_var.units = 'days since 2000-01-01'
+        time_var[:] = [0]
+        
+        # Create data variables
+        temp_var = ds.createVariable('temp', 'f4', ('time', 'depth', 'lat', 'lon'))
+        temp_var[:] = temp[np.newaxis, :, :, :]
+        temp_var.long_name = 'Temperature'
+        temp_var.units = 'degC'
+        
+        salt_var = ds.createVariable('salt', 'f4', ('time', 'depth', 'lat', 'lon'))
+        salt_var[:] = salt[np.newaxis, :, :, :]
+        salt_var.long_name = 'Salinity'
+        salt_var.units = 'psu'
+        
+        u_var = ds.createVariable('u', 'f4', ('time', 'depth', 'lat', 'lon'))
+        u_var[:] = u[np.newaxis, :, :, :]
+        u_var.long_name = 'Zonal velocity'
+        u_var.units = 'm/s'
+        
+        v_var = ds.createVariable('v', 'f4', ('time', 'depth', 'lat', 'lon'))
+        v_var[:] = v[np.newaxis, :, :, :]
+        v_var.long_name = 'Meridional velocity'
+        v_var.units = 'm/s'
+        
+        eta_var = ds.createVariable('eta_t', 'f4', ('time', 'lat', 'lon'))
+        eta_var[:] = eta_t[np.newaxis, :, :]
+        eta_var.long_name = 'Sea surface height'
+        eta_var.units = 'meters'
 
 
-@mcp.tool(name="pdaf_print_da_types", description="Print available DA method types in PDAF")
-def pdaf_print_da_types(verbose: int = 1) -> dict:
-    """
-    Print all available data assimilation method types in PDAF to the console.
-    
-    Args:
-        verbose: Verbosity flag. If 0, no output; if > 0, prints list to stdout.
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.print_da_types(verbose)
-        return {"success": True, "result": "DA types printed to console", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+def _flatten_state(temp: np.ndarray, salt: np.ndarray, u: np.ndarray, v: np.ndarray, eta_t: np.ndarray) -> np.ndarray:
+    """Flatten 3D/2D ocean fields into 1D state vector."""
+    return np.concatenate([
+        temp.ravel(),
+        salt.ravel(),
+        u.ravel(),
+        v.ravel(),
+        eta_t.ravel()
+    ])
 
 
-@mcp.tool(name="pdaf_print_info", description="Print PDAF configuration and status information")
-def pdaf_print_info(printtype: int) -> dict:
-    """
-    Print PDAF configuration and status information.
+def _unflatten_state(state: np.ndarray, nz: int, ny: int, nx: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Unflatten 1D state vector back to 3D/2D ocean fields."""
+    n_3d = nz * ny * nx
+    n_2d = ny * nx
     
-    Args:
-        printtype: Type of information to print
-                   1: Print filter type and settings
-                   2: Print timing information
-                   3: Print memory usage
+    temp = state[0:n_3d].reshape((nz, ny, nx))
+    salt = state[n_3d:2*n_3d].reshape((nz, ny, nx))
+    u = state[2*n_3d:3*n_3d].reshape((nz, ny, nx))
+    v = state[3*n_3d:4*n_3d].reshape((nz, ny, nx))
+    eta_t = state[4*n_3d:4*n_3d+n_2d].reshape((ny, nx))
     
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.print_info(printtype)
-        return {"success": True, "result": f"Info type {printtype} printed to console", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    return temp, salt, u, v, eta_t
 
 
-@mcp.tool(name="pdaf_reset_forget", description="Reset the forgetting factor in PDAF")
-def pdaf_reset_forget(forget_in: float) -> dict:
+def _state_indices_for_temp(obs_lon: np.ndarray, obs_lat: np.ndarray,
+                            lon: np.ndarray, lat: np.ndarray, 
+                            nz: int, ny: int, nx: int) -> np.ndarray:
     """
-    Reset the forgetting factor used in ensemble filters.
-    
-    The forgetting factor is used for covariance inflation.
-    A value less than 1.0 inflates the ensemble spread.
-    
-    For local ensemble Kalman filters, the forgetting factor can be set
-    either globally (outside the loop over local domains) or differently
-    for each local analysis domain (within the loop).
-    
-    Args:
-        forget_in: New forgetting factor value
-    
-    Returns:
-        dict: A dictionary containing the success status.
+    Map observation lon/lat to state vector indices for temperature at k=0 layer.
+    Uses nearest-neighbor approach.
     """
-    try:
-        PDAF.reset_forget(forget_in)
-        return {"success": True, "result": f"Forgetting factor reset to {forget_in}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    indices = []
+    for olon, olat in zip(obs_lon, obs_lat):
+        i = np.argmin(np.abs(lon - olon))
+        j = np.argmin(np.abs(lat - olat))
+        k = 0
+        idx = k * ny * nx + j * nx + i
+        indices.append(idx)
+    return np.array(indices)
 
 
-@mcp.tool(name="pdaf_set_debug_flag", description="Activate or deactivate PDAF debug output")
-def pdaf_set_debug_flag(debugval: int) -> dict:
-    """
-    Activate or deactivate debug output for PDAF.
-    
-    When activated, debug information is sent to screen output.
-    The output ends when the debug flag is set to 0.
-    
-    Args:
-        debugval: Value for debugging flag (0 to disable, non-zero to enable)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.set_debug_flag(debugval)
-        return {"success": True, "result": f"Debug flag set to {debugval}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+def _read_state_nc(filepath: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Read ocean state from NetCDF file."""
+    with nc.Dataset(filepath, 'r') as ds:
+        lon = ds.variables['lon'][:]
+        lat = ds.variables['lat'][:]
+        depth = ds.variables['depth'][:]
+        temp = ds.variables['temp'][0, :, :, :]
+        salt = ds.variables['salt'][0, :, :, :]
+        u = ds.variables['u'][0, :, :, :]
+        v = ds.variables['v'][0, :, :, :]
+        eta_t = ds.variables['eta_t'][0, :, :]
+    return lon, lat, depth, temp, salt, u, v, eta_t
 
 
-@mcp.tool(name="pdaf_set_offline_mode", description="Set PDAF to offline mode")
-def pdaf_set_offline_mode(screen: int) -> dict:
+def _gaspari_cohn(r: float, c: float) -> float:
     """
-    Set PDAF to offline mode for offline data assimilation.
+    Gaspari-Cohn correlation function for localization.
     
     Args:
-        screen: Screen output level (0 for no output)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.set_offline_mode(screen)
-        return {"success": True, "result": f"Offline mode set with screen={screen}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_get_assim_flag", description="Get the flag indicating if DA was performed in last time step")
-def pdaf_get_assim_flag() -> dict:
-    """
-    Return the flag that indicates if the DA is performed in the last time step.
-    This only works for online DA systems.
+        r: Distance between two points
+        c: Cutoff radius (localization radius)
     
     Returns:
-        dict: A dictionary containing:
-            - did_assim: 1 for assimilation performed, 0 otherwise
+        Correlation value between 0 and 1
     """
-    try:
-        did_assim = PDAF.get_assim_flag()
-        return {"success": True, "result": {"did_assim": int(did_assim)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_get_localfilter", description="Check whether a local filter is used")
-def pdaf_get_localfilter() -> dict:
-    """
-    Return whether a local filter is used.
-    
-    Returns:
-        dict: A dictionary containing:
-            - lfilter: 1 for local filters (domain-localized), 0 for global filters
-    """
-    try:
-        lfilter = PDAF.get_localfilter()
-        return {"success": True, "result": {"lfilter": int(lfilter)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_get_memberid", description="Get the ensemble member ID on the current process")
-def pdaf_get_memberid(memberid: int = 0) -> dict:
-    """
-    Return the ensemble member ID on the current process.
-    
-    This can be called during ensemble integration if ensemble-specific
-    forcing is read. It can also be used in user-supplied functions.
-    
-    Args:
-        memberid: Input member ID (can be any value)
+    z = r / c
     
-    Returns:
-        dict: A dictionary containing:
-            - memberid: Index in the local ensemble
-    """
-    try:
-        result = PDAF.get_memberid(memberid)
-        return {"success": True, "result": {"memberid": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    if z >= 2:
+        return 0.0
+    elif z >= 1:
+        term1 = z**5 / 12.0
+        term2 = z**4 / 2.0
+        term3 = 5.0 * z**3 / 8.0
+        term4 = 5.0 * z**2 / 3.0
+        result = -term1 + term2 + term3 - term4 + 5.0 * z - 4.0 + 2.0 / (3.0 * z)
+        return result
+    else:  # z < 1
+        term1 = z**5 / 4.0
+        term2 = z**4 / 2.0
+        term3 = 5.0 * z**3 / 8.0
+        result = -term1 + term2 + term3 + 1.0
+        return result
 
 
 # ============================================================================
-# PDAF Diagnostic Tools
+# MCP Tool 1: Generate Demo Ocean Data
 # ============================================================================
 
-@mcp.tool(name="pdaf_diag_ensmean", description="Compute ensemble mean of state vectors")
-def pdaf_diag_ensmean(dim: int, dim_ens: int, ens: List[List[float]]) -> dict:
-    """
-    Compute the ensemble mean of the state ensemble.
-    
-    Args:
-        dim: State dimension
-        dim_ens: Ensemble size
-        ens: State ensemble (2D list of shape [dim, dim_ens])
-    
-    Returns:
-        dict: A dictionary containing:
-            - state: Ensemble mean (list of length dim)
-            - status: Status flag (0=success)
-    """
-    try:
-        ens_np = np.array(ens, dtype=np.float64)
-        state = np.zeros(dim, dtype=np.float64)
+@mcp.tool(
+    name="generate_demo_ocean_data",
+    description="Generate synthetic ocean data for EnOI testing. Creates restart.nc (background state), ensemble members, and temperature observations at surface."
+)
+def generate_demo_ocean_data(
+    nx: int = 20,
+    ny: int = 20,
+    nz: int = 5,
+    n_ensemble: int = 10,
+    n_obs: int = 50,
+    lon_min: float = 0.0,
+    lon_max: float = 20.0,
+    lat_min: float = 0.0,
+    lat_max: float = 20.0,
+    depth_max: float = 100.0,
+    restart_path: str = "restart.nc",
+    ensemble_dir: str = "ensemble_data",
+    obs_path: str = "obs.nc",
+    ensemble_noise_std: float = 0.5,
+    obs_noise_std: float = 0.3,
+    seed: int = 42
+) -> Dict[str, Any]:
+    """
+    Generate synthetic ocean data for EnOI testing.
+    
+    Creates three types of files:
+    1. Background state (restart.nc): Initial ocean state
+    2. Static ensemble (ensemble_data/member_*.nc): Ensemble members for error covariance
+    3. Observations (obs.nc): Temperature observations at surface (k=0)
+    
+    Args:
+        nx, ny, nz: Grid dimensions (longitude, latitude, depth)
+        n_ensemble: Number of ensemble members
+        n_obs: Number of observations
+        lon_min, lon_max, lat_min, lat_max, depth_max: Coordinate ranges
+        restart_path: Path to background state file
+        ensemble_dir: Directory for ensemble members
+        obs_path: Path to observation file
+        ensemble_noise_std: Noise level for ensemble perturbations
+        obs_noise_std: Observation error standard deviation
+        seed: Random seed for reproducibility
+    
+    Returns:
+        Status dictionary with file paths and metadata
+    """
+    np.random.seed(seed)
+    
+    # Create coordinate grids
+    lon = np.linspace(lon_min, lon_max, nx)
+    lat = np.linspace(lat_min, lat_max, ny)
+    depth = np.linspace(0, depth_max, nz)
+    
+    LON, LAT, DEPTH = np.meshgrid(lon, lat, depth, indexing='ij')
+    LON = LON.T
+    LAT = LAT.T
+    DEPTH = DEPTH.T
+    
+    # Generate background state (restart.nc)
+    temp = 25.0 - 0.5 * (LAT - 20.0) - 2.0 * DEPTH
+    salt = 35.0 + np.random.randn(nz, ny, nx) * 0.1
+    u = np.sin(LON / 5.0) * 0.5
+    v = np.cos(LAT / 5.0) * 0.5
+    eta_t = np.random.randn(ny, nx) * 0.1
+    
+    _write_model_nc(restart_path, lon, lat, depth, temp, salt, u, v, eta_t)
+    
+    # Generate ensemble members
+    os.makedirs(ensemble_dir, exist_ok=True)
+    ensemble_paths = []
+    
+    for i in range(n_ensemble):
+        member_path = os.path.join(ensemble_dir, f"member_{i+1:03d}.nc")
         
-        state_out, status = PDAF.diag_ensmean(dim, dim_ens, state, ens_np)
-        return {
-            "success": True,
-            "result": {
-                "state": state_out.tolist(),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_diag_effsample", description="Compute effective sample size for particle filter")
-def pdaf_diag_effsample(dim_sample: int, weights: List[float]) -> dict:
-    """
-    Compute effective ensemble size from particle filter weights.
-    
-    This is a diagnostic for particle filters that measures how many
-    particles are effectively contributing to the estimate.
-    
-    Based on Doucet et al. (2001), it is defined as:
-    N_eff = 1 / sum(w_i^2)
-    where w_i is the weight of particle i.
-    
-    If N_eff = N, all weights are identical and the filter has no influence.
-    If N_eff = 0, the filter is collapsed.
-    
-    Args:
-        dim_sample: Sample size (number of particles)
-        weights: Particle weights (list of length dim_sample)
-    
-    Returns:
-        dict: A dictionary containing:
-            - n_eff: Effective sample size
-    """
-    try:
-        weights_np = np.array(weights, dtype=np.float64)
-        n_eff = PDAF.diag_effsample(dim_sample, weights_np)
-        return {"success": True, "result": {"n_eff": float(n_eff)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        temp_m = temp + np.random.randn(nz, ny, nx) * ensemble_noise_std
+        salt_m = salt + np.random.randn(nz, ny, nx) * ensemble_noise_std * 0.5
+        u_m = u + np.random.randn(nz, ny, nx) * ensemble_noise_std * 0.2
+        v_m = v + np.random.randn(nz, ny, nx) * ensemble_noise_std * 0.2
+        eta_m = eta_t + np.random.randn(ny, nx) * ensemble_noise_std * 0.1
+        
+        _write_model_nc(member_path, lon, lat, depth, temp_m, salt_m, u_m, v_m, eta_m)
+        ensemble_paths.append(member_path)
+    
+    # Generate observations (temperature at surface k=0)
+    obs_lon = np.random.uniform(lon_min, lon_max, n_obs)
+    obs_lat = np.random.uniform(lat_min, lat_max, n_obs)
+    
+    # Create "true" observations from background + noise
+    obs_temp = []
+    for olon, olat in zip(obs_lon, obs_lat):
+        i = np.argmin(np.abs(lon - olon))
+        j = np.argmin(np.abs(lat - olat))
+        true_val = temp[0, j, i] + np.random.randn() * obs_noise_std
+        obs_temp.append(true_val)
+    obs_temp = np.array(obs_temp)
+    
+    # Write observations to NetCDF
+    with nc.Dataset(obs_path, 'w') as ds:
+        ds.createDimension('obs', n_obs)
+        
+        lon_var = ds.createVariable('lon', 'f4', ('obs',))
+        lon_var[:] = obs_lon
+        lon_var.units = 'degrees_east'
+        
+        lat_var = ds.createVariable('lat', 'f4', ('obs',))
+        lat_var[:] = obs_lat
+        lat_var.units = 'degrees_north'
+        
+        temp_var = ds.createVariable('temp', 'f4', ('obs',))
+        temp_var[:] = obs_temp
+        temp_var.long_name = 'Temperature'
+        temp_var.units = 'degC'
+        
+        error_var = ds.createVariable('error', 'f4', ('obs',))
+        error_var[:] = np.full(n_obs, obs_noise_std)
+        error_var.long_name = 'Observation error std'
+    
+    return {
+        "status": "success",
+        "restart_path": os.path.abspath(restart_path),
+        "ensemble_dir": os.path.abspath(ensemble_dir),
+        "n_ensemble": n_ensemble,
+        "obs_path": os.path.abspath(obs_path),
+        "n_obs": n_obs,
+        "grid_shape": {"nx": nx, "ny": ny, "nz": nz},
+        "state_vector_size": nx * ny * nz * 4 + nx * ny
+    }
 
 
 # ============================================================================
-# PDAFomi Module Tools
+# MCP Tool 2: Run EnOI Pipeline with Localization
 # ============================================================================
 
-@mcp.tool(name="pdafomi_init", description="Initialize PDAFomi with number of observation types")
-def pdafomi_init(n_obs: int) -> dict:
-    """
-    Allocate an array of obs_f derived type instances.
-    
-    This function initializes the number of observation types,
-    which should be called at the start of the DA system after PDAF.init.
-    
-    Args:
-        n_obs: Number of observation types
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.init(n_obs)
-        return {"success": True, "result": f"PDAFomi initialized with {n_obs} observation types", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_init_local", description="Initialize local observation types for local analysis")
-def pdafomi_init_local() -> dict:
-    """
-    Allocate an array of obs_l derived type instances for local analysis.
-    
-    This function initializes the number of observation types for each
-    local analysis domain, which should be called at the start of the
-    local analysis loop.
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.init_local()
-        return {"success": True, "result": "PDAFomi local initialized", "error": None}
+@mcp.tool(
+    name="run_enoi_pipeline",
+    description="Run Ensemble Optimal Interpolation (EnOI) data assimilation pipeline with optional Gaspari-Cohn localization. Computes analysis state from background, ensemble, and observations."
+)
+def run_enoi_pipeline(
+    restart_path: str = "restart.nc",
+    ensemble_dir: str = "ensemble_data",
+    obs_path: str = "obs.nc",
+    analysis_path: str = "restart_analysis.nc",
+    inflation_factor: float = 1.0,
+    localization_radius: float = 500.0
+) -> Dict[str, Any]:
+    """
+    Run Ensemble Optimal Interpolation (EnOI) data assimilation pipeline using pyPDAF.
+    
+    This implements the EnOI algorithm by:
+    1. Initialize PDAF with EnKF filtertype=200 (EnOI with static ensemble)
+    2. Load background state, static ensemble, and observations
+    3. Use PDAFomi to handle observation operator
+    4. Apply optional Gaspari-Cohn localization
+    5. Run offline assimilation
+    6. Write analysis state
+    
+    Args:
+        restart_path: Path to background state file
+        ensemble_dir: Directory containing ensemble member files
+        obs_path: Path to observation file
+        analysis_path: Output path for analysis state
+        inflation_factor: Covariance inflation factor (default 1.0)
+        localization_radius: Localization radius in km (default 500, 0 = no localization)
+    
+    Returns:
+        Status dictionary with analysis statistics
+    """
+    if not PYPDAF_AVAILABLE:
+        return {"status": "error", "message": "pyPDAF library is not available"}
+    
+    # Step 1: Load background state
+    lon, lat, depth, temp_b, salt_b, u_b, v_b, eta_b = _read_state_nc(restart_path)
+    nz, ny, nx = temp_b.shape
+    
+    state_b = _flatten_state(temp_b, salt_b, u_b, v_b, eta_b)
+    n_state = len(state_b)
+    
+    # Step 1b: Load ensemble members
+    member_files = sorted(glob.glob(os.path.join(ensemble_dir, "member_*.nc")))
+    n_ensemble = len(member_files)
+    
+    if n_ensemble == 0:
+        return {"status": "error", "message": f"No ensemble members found in {ensemble_dir}"}
+    
+    ensemble_states = np.zeros((n_state, n_ensemble), order='F')
+    for i, mfile in enumerate(member_files):
+        _, _, _, temp_m, salt_m, u_m, v_m, eta_m = _read_state_nc(mfile)
+        ensemble_states[:, i] = _flatten_state(temp_m, salt_m, u_m, v_m, eta_m)
+    
+    # Step 2: Load observations
+    with nc.Dataset(obs_path, 'r') as ds:
+        obs_lon = ds.variables['lon'][:]
+        obs_lat = ds.variables['lat'][:]
+        obs_temp = ds.variables['temp'][:]
+        obs_error = ds.variables['error'][:]
+    
+    n_obs = len(obs_temp)
+    
+    # Build observation indices (for temp at k=0)
+    obs_indices = _state_indices_for_temp(obs_lon, obs_lat, lon, lat, nz, ny, nx)
+    
+    # ========================================================================
+    # Step 3: Initialize PDAF for EnOI (offline mode)
+    # ========================================================================
+    
+    # FilterType: For EnOI, we use filtertype=200 (SEEK with fixed covariance)
+    # or filtertype=2 (EnKF) which works for static ensemble
+    filtertype = 2  # EnKF
+    subtype = 0      # Standard form
+    
+    # PDAF parameters
+    filter_param_i = np.array([n_state, n_ensemble], dtype=np.intc)
+    filter_param_r = np.array([inflation_factor], dtype=np.float64)
+    
+    # User-supplied function to initialize ensemble
+    def init_ens_pdaf(filtertype_in, dim_p, dim_ens, state_p, uinv, ens_p, status):
+        """Initialize ensemble in PDAF"""
+        ens_p[:, :] = ensemble_states
+        state_p[:] = state_b
+        return state_p, uinv, ens_p, status
+    
+    # Initialize PDAF
+    try:
+        _, _, status = pyPDAF.init(
+            filtertype, subtype, 0,  # step=0 for offline
+            filter_param_i, len(filter_param_i),
+            filter_param_r, len(filter_param_r),
+            py__init_ens_pdaf=init_ens_pdaf,
+            in_screen=1  # verbose level
+        )
+        if status != 0:
+            return {"status": "error", "message": f"PDAF init failed with status {status}"}
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_check_error", description="Check PDAFomi internal error flag")
-def pdafomi_check_error(flag: int = 0) -> dict:
-    """
-    Check the value of the PDAF-OMI internal error flag.
+        return {"status": "error", "message": f"PDAF init exception: {str(e)}"}
     
-    Since PDAF-OMI executes internal routines in which errors could occur
-    due to inconsistent configuration of observations, this function
-    allows checking for such errors.
+    # ========================================================================
+    # Step 4: Setup PDAFomi for observations
+    # ========================================================================
     
-    Args:
-        flag: Error flag input (can be any value)
+    # Initialize PDAFomi with 1 observation type
+    PDAFomi.init(1)
     
-    Returns:
-        dict: A dictionary containing:
-            - flag: Error flag value (0 = no error)
-    """
-    try:
-        result = PDAFomi.check_error(flag)
-        return {"success": True, "result": {"flag": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+    # Setup localization if requested
+    if localization_radius > 0:
+        # Convert radius from km to degrees (approximate)
+        radius_deg = localization_radius / 111.0
+        
+        # Initialize local analysis
+        PDAFomi.init_local()
+        
+        # Set localization
+        PDAF.set_localfilter(1)  # Enable local filter
+    
+    # Observation class to handle PDAFomi callbacks
+    class ObsHandler:
+        def __init__(self):
+            self.i_obs = 1
+            
+        def init_dim_obs_pdafomi(self, step, dim_obs):
+            """Initialize observation dimension"""
+            # Set OMI parameters
+            PDAFomi.set_doassim(self.i_obs, 1)  # Assimilate this obs type
+            PDAFomi.set_disttype(self.i_obs, 0)  # Cartesian distance
+            PDAFomi.set_ncoord(self.i_obs, 2)   # 2D coordinates
+            
+            # Create coordinate array for observations
+            ocoord_p = np.zeros((2, n_obs), order='F')
+            ocoord_p[0, :] = obs_lon
+            ocoord_p[1, :] = obs_lat
+            
+            # Set observation error
+            ivar_obs = 1.0 / (obs_error ** 2)
+            
+            # Set id_obs_p (state vector indices, 1-indexed for Fortran)
+            id_obs_p = np.zeros((1, n_obs), dtype=np.intc, order='F')
+            id_obs_p[0, :] = obs_indices + 1  # Fortran 1-indexing
+            
+            # Gather observation information
+            PDAFomi.set_id_obs_p(self.i_obs, 1, n_obs, id_obs_p)
+            PDAFomi.set_ivar_obs_p(self.i_obs, n_obs, ivar_obs)
+            PDAFomi.set_ocoord_p(self.i_obs, 2, n_obs, ocoord_p)
+            
+            # Set observation values
+            PDAFomi.set_obs_p(self.i_obs, n_obs, obs_temp)
+            
+            return n_obs
+    
+        def obs_op_pdafomi(self, step, dim_p, dim_obs_p, state_p, ostate):
+            """Observation operator"""
+            # Extract observed values from state vector
+            ostate[:] = state_p[obs_indices]
+            return ostate
+    
+    obs_handler = ObsHandler()
+    
+    # Collector class to handle state collection
+    class StateCollector:
+        def __init__(self):
+            self.analysis_state = np.copy(state_b)
+            
+        def collect_state_pdaf(self, dim_p, state_p):
+            """Collect state from model (not used in offline mode)"""
+            state_p[:] = self.analysis_state
+            return state_p
+        
+        def distribute_state_pdaf(self, dim_p, state_p):
+            """Distribute state to model"""
+            self.analysis_state[:] = state_p
+            return state_p
+        
+        def prepoststep_pdaf(self, step, dim_p, dim_ens, dim_ens_p, dim_obs_p, 
+                            state_p, uinv, ens_p, flag):
+            """Pre/post processing"""
+            if flag > 0:  # After analysis
+                self.analysis_state[:] = state_p
+            return state_p, uinv, ens_p
+    
+    collector = StateCollector()
+    
+    # Localization handler (if needed)
+    if localization_radius > 0:
+        # Create grid coordinates
+        lon_grid, lat_grid = np.meshgrid(lon, lat, indexing='ij')
+        
+        class LocalizationHandler:
+            def init_n_domains_pdaf(self, step, n_domains_p):
+                """Number of local analysis domains"""
+                n_domains_p = n_state
+                return n_domains_p
+            
+            def init_dim_l_pdaf(self, step, domain_p, dim_l):
+                """Dimension of local state vector"""
+                dim_l = n_state  # Full state for each domain
+                return dim_l
+            
+            def init_dim_obs_l_pdafomi(self, domain_p, step, dim_obs_f, dim_obs_l):
+                """Local observation dimension"""
+                # For each domain point, find observations within localization radius
+                i_domain = domain_p - 1  # Convert to 0-index
+                
+                # Get domain coordinates
+                state_lon = lon_grid.ravel()[i_domain % (nx*ny)]
+                state_lat = lat_grid.ravel()[i_domain % (nx*ny)]
+                
+                # Calculate distances to all observations
+                dx = obs_lon - state_lon
+                dy = obs_lat - state_lat
+                dist = np.sqrt(dx**2 + dy**2)
+                
+                # Count observations within localization radius
+                dim_obs_l = np.sum(dist <= radius_deg)
+                return dim_obs_l
+        
+        loc_handler = LocalizationHandler()
+        
+        # Run offline assimilation with localization
+        try:
+            status = 0
+            pyPDAF.assim_offline_local_nondiagr(
+                collector.collect_state_pdaf,
+                collector.distribute_state_pdaf,
+                obs_handler.init_dim_obs_pdafomi,
+                obs_handler.obs_op_pdafomi,
+                collector.prepoststep_pdaf,
+                loc_handler.init_n_domains_pdaf,
+                loc_handler.init_dim_l_pdaf,
+                loc_handler.init_dim_obs_l_pdafomi,
+                status
+            )
+        except Exception as e:
+            return {"status": "error", "message": f"Assimilation failed: {str(e)}"}
+    else:
+        # Run offline assimilation without localization (global)
+        try:
+            status = 0
+            pyPDAF.assim_offline_global_nondiagr(
+                collector.collect_state_pdaf,
+                collector.distribute_state_pdaf,
+                obs_handler.init_dim_obs_pdafomi,
+                obs_handler.obs_op_pdafomi,
+                collector.prepoststep_pdaf,
+                status
+            )
+        except Exception as e:
+            return {"status": "error", "message": f"Assimilation failed: {str(e)}"}
+    
+    # ========================================================================
+    # Step 6: Write analysis state
+    # ========================================================================
+    
+    # Unflatten analysis state
+    state_a = collector.analysis_state
+    temp_a, salt_a, u_a, v_a, eta_a = _unflatten_state(state_a, nz, ny, nx)
+    _write_model_nc(analysis_path, lon, lat, depth, temp_a, salt_a, u_a, v_a, eta_a)
+    
+    # Compute statistics
+    increment = state_a - state_b
+    innovation = obs_temp - state_b[obs_indices]
+    
+    rms_increment = float(np.sqrt(np.mean(increment**2)))
+    max_increment = float(np.max(np.abs(increment)))
+    rms_innovation = float(np.sqrt(np.mean(innovation**2)))
+    
+    # Finalize PDAF
+    PDAF.deallocate()
+    
+    return {
+        "status": "success",
+        "analysis_path": os.path.abspath(analysis_path),
+        "n_ensemble": n_ensemble,
+        "n_obs": n_obs,
+        "n_state": n_state,
+        "rms_innovation": rms_innovation,
+        "rms_increment": rms_increment,
+        "max_increment": max_increment,
+        "inflation_factor": inflation_factor,
+        "localization_radius_km": localization_radius if localization_radius > 0 else "none"
+    }
 
-@mcp.tool(name="pdafomi_set_debug_flag", description="Activate or deactivate PDAFomi debug output")
-def pdafomi_set_debug_flag(debugval: int) -> dict:
-    """
-    Activate or deactivate debug output for PDAFomi.
-    
-    Args:
-        debugval: Value for debugging flag (0 to disable, non-zero to enable)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_debug_flag(debugval)
-        return {"success": True, "result": f"PDAFomi debug flag set to {debugval}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
 
+# ============================================================================
+# Create MCP Server App
+# ============================================================================
 
-@mcp.tool(name="pdafomi_set_doassim", description="Set whether to assimilate a given observation type")
-def pdafomi_set_doassim(i_obs: int, doassim: int) -> dict:
-    """
-    Set the doassim attribute for a given observation type.
-    
-    Args:
-        i_obs: Index of observation type
-        doassim: 0) do not assimilate; 1) assimilate the observation type
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_doassim(i_obs, doassim)
-        return {"success": True, "result": f"Observation type {i_obs} doassim set to {doassim}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_set_disttype", description="Set distance calculation method for observation localization")
-def pdafomi_set_disttype(i_obs: int, disttype: int) -> dict:
-    """
-    Set the observation localization distance calculation method.
-    
-    Args:
-        i_obs: Index of observation type
-        disttype: Type of distance calculation:
-                  0) Cartesian (any units)
-                  1) Cartesian periodic (any units)
-                  2) Geographic distance in metres (lat/lon in radians)
-                  3) Haversine formula for distance on sphere
-                  10) 3D Cartesian with separate horizontal/vertical
-                  11) 3D Cartesian periodic with separate horizontal/vertical
-                  12) Geographic horizontal + user vertical
-                  13) Haversine horizontal + user vertical
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_disttype(i_obs, disttype)
-        return {"success": True, "result": f"Observation type {i_obs} disttype set to {disttype}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_set_ncoord", description="Set number of spatial dimensions for observations")
-def pdafomi_set_ncoord(i_obs: int, ncoord: int) -> dict:
-    """
-    Set the number of spatial dimensions of observations.
-    
-    Args:
-        i_obs: Index of observation type
-        ncoord: Dimension of the observation coordinate (e.g., 2 for 2D)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_ncoord(i_obs, ncoord)
-        return {"success": True, "result": f"Observation type {i_obs} ncoord set to {ncoord}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_nobstypes", description="Get number of active observation types")
-def pdafomi_diag_nobstypes(nobs: int = 0) -> dict:
-    """
-    Get the number of observation types that are active in an assimilation run.
-    
-    Args:
-        nobs: Number of observation types (input can be arbitrary)
-    
-    Returns:
-        dict: A dictionary containing:
-            - nobs: Number of active observation types
-    """
-    try:
-        result = PDAFomi.diag_nobstypes(nobs)
-        return {"success": True, "result": {"nobs": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_dimobs", description="Get observation dimensions for each observation type")
-def pdafomi_diag_dimobs() -> dict:
-    """
-    Get observation dimension for each observation type.
-    
-    Returns:
-        dict: A dictionary containing:
-            - dim_obs: Observation dimension for each type (list)
-    """
-    try:
-        result = PDAFomi.diag_dimobs()
-        return {"success": True, "result": {"dim_obs": result.tolist()}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# ============================================================================
-# PDAFlocal Module Tools
-# ============================================================================
-
-@mcp.tool(name="pdaflocal_set_indices", description="Set index mapping from local to global state vector")
-def pdaflocal_set_indices(dim_l: int, map_indices: List[int]) -> dict:
-    """
-    Set index vector to map local state vector to global state vectors.
-    
-    This is called in the user-supplied function py__init_dim_l_pdaf.
-    Each element of map is an index of the global state vector (1-based).
-    
-    E.g., map[0] = 2 means that the first element of local state vector
-    is the 2nd element of the global state vector.
-    
-    Args:
-        dim_l: Dimension of local state vector
-        map_indices: Index array for mapping between local and global state vector
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        map_np = np.array(map_indices, dtype=np.int32)
-        PDAFlocal.set_indices(dim_l, map_np)
-        return {"success": True, "result": f"Local indices set for dim_l={dim_l}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaflocal_set_increment_weights", description="Set local increment weights for vertical localization")
-def pdaflocal_set_increment_weights(dim_l: int, weights: List[float]) -> dict:
-    """
-    Initialize a PDAF-internal local array of increment weights.
-    
-    The weights are applied where the local state vector is weighted.
-    These can be used to apply vertical localization or implement
-    weakly-coupled assimilation.
-    
-    Args:
-        dim_l: Dimension of local state vector
-        weights: Weights array (list of length dim_l)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        weights_np = np.array(weights, dtype=np.float64)
-        PDAFlocal.set_increment_weights(dim_l, weights_np)
-        return {"success": True, "result": f"Increment weights set for dim_l={dim_l}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaflocal_clear_increment_weights", description="Deallocate local increment weight vector")
-def pdaflocal_clear_increment_weights() -> dict:
-    """
-    Deallocate the local increment weight vector set by set_increment_weights.
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFlocal.clear_increment_weights()
-        return {"success": True, "result": "Increment weights cleared", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# ============================================================================
-# Additional PDAF Diagnostic Tools
-# ============================================================================
-
-@mcp.tool(name="pdaf_diag_stddev_nompi", description="Compute ensemble standard deviation without MPI")
-def pdaf_diag_stddev_nompi(
-    dim: int,
-    dim_ens: int,
-    ens: List[List[float]],
-    do_mean: int
-) -> dict:
-    """
-    Compute ensemble standard deviation and ensemble mean without MPI.
-    
-    Args:
-        dim: State dimension
-        dim_ens: Ensemble size
-        ens: State ensemble (2D list of shape [dim, dim_ens])
-        do_mean: Whether to compute ensemble mean (1=yes, 0=no)
-    
-    Returns:
-        dict: A dictionary containing:
-            - state: State vector (ensemble mean if do_mean=1)
-            - stddev: Standard deviation of ensemble
-            - status: Status flag (0=success)
-    """
-    try:
-        ens_np = np.array(ens, dtype=np.float64)
-        state = np.zeros(dim, dtype=np.float64)
-        
-        state_out, stddev, status = PDAF.diag_stddev_nompi(dim, dim_ens, state, ens_np, do_mean)
-        return {
-            "success": True,
-            "result": {
-                "state": state_out.tolist(),
-                "stddev": float(stddev),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_diag_variance_nompi", description="Compute ensemble variance without MPI")
-def pdaf_diag_variance_nompi(
-    dim: int,
-    dim_ens: int,
-    ens: List[List[float]],
-    do_mean: int,
-    do_stddev: int
-) -> dict:
-    """
-    Compute ensemble variance/standard deviation and mean without MPI.
-    
-    Args:
-        dim: State dimension
-        dim_ens: Ensemble size
-        ens: State ensemble (2D list of shape [dim, dim_ens])
-        do_mean: Whether to compute ensemble mean (1=yes, 0=no)
-        do_stddev: Whether to compute the ensemble mean standard deviation (1=yes, 0=no)
-    
-    Returns:
-        dict: A dictionary containing:
-            - state: State vector (ensemble mean if do_mean=1)
-            - variance: Variance state vector
-            - stddev: Standard deviation of ensemble
-            - status: Status flag (0=success)
-    """
-    try:
-        ens_np = np.array(ens, dtype=np.float64)
-        state = np.zeros(dim, dtype=np.float64)
-        
-        state_out, variance, stddev, status = PDAF.diag_variance_nompi(
-            dim, dim_ens, state, ens_np, do_mean, do_stddev
-        )
-        return {
-            "success": True,
-            "result": {
-                "state": state_out.tolist(),
-                "variance": variance.tolist(),
-                "stddev": float(stddev),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_diag_rmsd_nompi", description="Compute RMSD between two vectors without MPI")
-def pdaf_diag_rmsd_nompi(
-    dim_p: int,
-    statea_p: List[float],
-    stateb_p: List[float]
-) -> dict:
-    """
-    Compute the root mean squared distance between two vectors without MPI.
-    
-    Args:
-        dim_p: State dimension
-        statea_p: State vector A (list of length dim_p)
-        stateb_p: State vector B (list of length dim_p)
-    
-    Returns:
-        dict: A dictionary containing:
-            - rmsd_p: Root mean squared distance
-            - status: Status flag (0=success)
-    """
-    try:
-        statea_np = np.array(statea_p, dtype=np.float64)
-        stateb_np = np.array(stateb_p, dtype=np.float64)
-        
-        rmsd_p, status = PDAF.diag_rmsd_nompi(dim_p, statea_np, stateb_np)
-        return {
-            "success": True,
-            "result": {
-                "rmsd_p": float(rmsd_p),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_diag_ensstats", description="Compute ensemble skewness and kurtosis")
-def pdaf_diag_ensstats(
-    dim: int,
-    dim_ens: int,
-    element: int,
-    ens: List[List[float]]
-) -> dict:
-    """
-    Compute the skewness and kurtosis of the ensemble for a given state vector element.
-    
-    The definition used for kurtosis follows Lawson & Hansen (2004).
-    
-    Args:
-        dim: PE-local state dimension
-        dim_ens: Ensemble size
-        element: ID of element to be used
-        ens: State ensemble (2D list of shape [dim, dim_ens])
-    
-    Returns:
-        dict: A dictionary containing:
-            - skewness: Skewness of ensemble
-            - kurtosis: Kurtosis of ensemble
-            - status: Status flag (0=success)
-    """
-    try:
-        ens_np = np.array(ens, dtype=np.float64)
-        state = np.zeros(dim, dtype=np.float64)
-        
-        skewness, kurtosis, status = PDAF.diag_ensstats(dim, dim_ens, element, state, ens_np)
-        return {
-            "success": True,
-            "result": {
-                "skewness": float(skewness),
-                "kurtosis": float(kurtosis),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_sample_ens", description="Generate ensemble from EOF modes and singular values")
-def pdaf_sample_ens(
-    dim: int,
-    dim_ens: int,
-    modes: List[List[float]],
-    svals: List[float],
-    state: List[float],
-    verbose: int,
-    flag: int = 0
-) -> dict:
-    """
-    Generate an ensemble from singular values and their vectors (EOF modes).
-    
-    The singular values and vectors are derived from ensemble anomalies.
-    This ensemble anomaly can be obtained from a time anomaly of a model
-    trajectory using PDAF.eofcovar.
-    
-    Args:
-        dim: Size of the state vector
-        dim_ens: Ensemble size
-        modes: Array of EOF modes/matrix of singular vectors (shape [dim, dim_ens-1])
-        svals: Singular values (list of length dim_ens-1)
-        state: PE-local model mean state (list of length dim)
-        verbose: Verbosity flag
-        flag: Status flag input
-    
-    Returns:
-        dict: A dictionary containing:
-            - modes: Updated EOF modes
-            - state: Updated mean state
-            - ens: Generated state ensemble (shape [dim, dim_ens])
-            - flag: Status flag
-    """
-    try:
-        modes_np = np.array(modes, dtype=np.float64)
-        svals_np = np.array(svals, dtype=np.float64)
-        state_np = np.array(state, dtype=np.float64)
-        
-        modes_out, state_out, ens, flag_out = PDAF.sample_ens(
-            dim, dim_ens, modes_np, svals_np, state_np, verbose, flag
-        )
-        return {
-            "success": True,
-            "result": {
-                "modes": modes_out.tolist(),
-                "state": state_out.tolist(),
-                "ens": ens.tolist(),
-                "flag": int(flag_out)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_local_weight", description="Compute localization weight for a given distance")
-def pdaf_local_weight(
-    wtype: int,
-    rtype: int,
-    cradius: float,
-    sradius: float,
-    distance: float,
-    nrows: int,
-    ncols: int,
-    a: List[List[float]],
-    var_obs: float,
-    verbose: int
-) -> dict:
-    """
-    Get localization weight for given distance, cut-off radius, support radius,
-    weighting type, and weighting function.
-    
-    Args:
-        wtype: Type of weight function:
-               0: unit weight (weight=1 up to distance=cradius)
-               1: exponential decrease (weight=1/e at distance=sradius)
-               2: 5th order polynomial (Gaspari and Cohn 1999)
-        rtype: Type of regulated weighting:
-               !=1: no regulation
-               1: regulated by variance of matrix A and observation variance
-        cradius: Cut-off radius where weight=0 beyond it
-        sradius: Support radius of localization function
-        distance: Distance to observation
-        nrows: Number of rows in matrix A
-        ncols: Number of columns in matrix A
-        a: Ensemble perturbation/anomaly matrix (shape [nrows, ncols])
-        var_obs: Observation variance
-        verbose: Verbosity flag
-    
-    Returns:
-        dict: A dictionary containing:
-            - weight: Localization weight
-    """
-    try:
-        a_np = np.array(a, dtype=np.float64)
-        
-        weight = PDAF.local_weight(
-            wtype, rtype, cradius, sradius, distance,
-            nrows, ncols, a_np, var_obs, verbose
-        )
-        return {"success": True, "result": {"weight": float(weight)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_get_local_type", description="Get the localization type of the selected filter")
-def pdaf_get_local_type() -> dict:
-    """
-    Return the information on the localization type of the selected filter.
-    
-    Returns:
-        dict: A dictionary containing:
-            - localtype: Localization type
-                0: no localization; global filter
-                1: domain localization (LESTKF, LETKF, LNETF, LSEIK)
-                2: covariance localization (LEnKF)
-                3: covariance loc. but observation handling like domain localization (ENSRF)
-    """
-    try:
-        localtype = PDAF.get_local_type()
-        return {"success": True, "result": {"localtype": int(localtype)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_set_ens_pointer", description="Get a numpy array view of the internal ensemble array")
-def pdaf_set_ens_pointer() -> dict:
-    """
-    Return the ensemble in a numpy array with the same memory address as
-    PDAF's internal ensemble array, allowing for manual ensemble modification.
-    
-    Returns:
-        dict: A dictionary containing:
-            - ens_shape: Shape of the ensemble array [dim, dim_ens]
-            - status: Status flag
-    """
-    try:
-        ens_ptr, status = PDAF.set_ens_pointer()
-        return {
-            "success": True,
-            "result": {
-                "ens_shape": list(ens_ptr.shape),
-                "ens": ens_ptr.tolist(),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# ============================================================================
-# Additional PDAFomi Tools
-# ============================================================================
-
-@mcp.tool(name="pdafomi_set_obs_err_type", description="Set observation error distribution type")
-def pdafomi_set_obs_err_type(i_obs: int, obs_err_type: int) -> dict:
-    """
-    Set the type of observation error distribution for a given observation type.
-    
-    Args:
-        i_obs: Index of observation type
-        obs_err_type: Type of observation error distribution:
-                      0: Gaussian (default)
-                      1: double exponential (Laplacian)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_obs_err_type(i_obs, obs_err_type)
-        return {"success": True, "result": f"Observation type {i_obs} error type set to {obs_err_type}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_set_use_global_obs", description="Set whether to use global or process-local observations")
-def pdafomi_set_use_global_obs(i_obs: int, use_global_obs: int) -> dict:
-    """
-    Set switch for using process-local or global observations.
-    
-    By default (use_global_obs=1), PDAF-OMI gathers the entire observation
-    vector for all processes. Setting use_global_obs=0 uses only process-local
-    observations, which can save computational cost.
-    
-    Args:
-        i_obs: Index of observation type
-        use_global_obs: 0: Using process-local observations
-                        1: Using cross-process observations (default)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_use_global_obs(i_obs, use_global_obs)
-        return {"success": True, "result": f"Observation type {i_obs} use_global_obs set to {use_global_obs}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_obs_rmsd", description="Compute RMSD between observations and observed model state")
-def pdafomi_diag_obs_rmsd(nobs: int, verbose: int) -> dict:
-    """
-    Compute root mean squared distance between observations and observed
-    model state for each observation type.
-    
-    Args:
-        nobs: Number of observation types
-        verbose: Verbosity flag
-    
-    Returns:
-        dict: A dictionary containing:
-            - nobs: Number of observation types
-            - rmsd: Vector of RMSD values for each observation type
-    """
-    try:
-        nobs_out, rmsd = PDAFomi.diag_obs_rmsd(nobs, verbose)
-        return {
-            "success": True,
-            "result": {
-                "nobs": int(nobs_out),
-                "rmsd": rmsd.tolist()
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_stats", description="Compute statistics comparing observations and observed ensemble mean")
-def pdafomi_diag_stats(nobs: int, verbose: int) -> dict:
-    """
-    Compute a selection of 6 statistics comparing observations and
-    observed ensemble mean for each observation type.
-    
-    Statistics include:
-    - (1,:) correlations between observation and observed ensemble mean
-    - (2,:) centered RMS difference
-    - (3,:) mean bias (observation minus observed ensemble mean)
-    - (4,:) mean absolute difference
-    - (5,:) variance of observations
-    - (6,:) variance of observed ensemble mean
-    
-    Args:
-        nobs: Number of observation types
-        verbose: Verbosity flag
-    
-    Returns:
-        dict: A dictionary containing:
-            - nobs: Number of observation types
-            - obsstats: Array of observation statistics (shape [6, nobs])
-    """
-    try:
-        nobs_out, obsstats = PDAFomi.diag_stats(nobs, verbose)
-        return {
-            "success": True,
-            "result": {
-                "nobs": int(nobs_out),
-                "obsstats": obsstats.tolist()
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# ============================================================================
-# Additional PDAF Setter Functions (不需要回调和MPI)
-# ============================================================================
-
-@mcp.tool(name="pdaf_set_comm_pdaf", description="Set the MPI communicator used by PDAF")
-def pdaf_set_comm_pdaf(in_comm_pdaf: int) -> dict:
-    """
-    Set the MPI communicator used by PDAF.
-    
-    By default, PDAF assumes it can use all available processes (MPI_COMM_WORLD).
-    By using this function, we limit the number of processes that can be used
-    by PDAF to the given MPI communicator.
-    
-    Args:
-        in_comm_pdaf: MPI communicator for PDAF (integer handle)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.set_comm_pdaf(in_comm_pdaf)
-        return {"success": True, "result": f"PDAF communicator set to {in_comm_pdaf}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_set_iparam", description="Set integer parameters for PDAF")
-def pdaf_set_iparam(idval: int, value: int, flag: int = 0) -> dict:
-    """
-    Set integer parameters for PDAF.
-    
-    This function provides an alternative way to set integer parameters
-    instead of providing all parameters in the call to PDAF.init.
-    
-    Args:
-        idval: Index of parameter
-        value: Parameter value
-        flag: Status flag input (default 0)
-    
-    Returns:
-        dict: A dictionary containing:
-            - flag: Status flag (0 for no error)
-    """
-    try:
-        result = PDAF.set_iparam(idval, value, flag)
-        return {"success": True, "result": {"flag": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_set_rparam", description="Set floating-point parameters for PDAF")
-def pdaf_set_rparam(idval: int, value: float, flag: int = 0) -> dict:
-    """
-    Set floating-point parameters for PDAF.
-    
-    This function provides an alternative way to set real parameters
-    instead of providing all parameters in the call to PDAF.init.
-    
-    Args:
-        idval: Index of parameter
-        value: Parameter value (float)
-        flag: Status flag input (default 0)
-    
-    Returns:
-        dict: A dictionary containing:
-            - flag: Status flag (0 for no error)
-    """
-    try:
-        result = PDAF.set_rparam(idval, value, flag)
-        return {"success": True, "result": {"flag": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_set_memberid", description="Set the ensemble member index to a given value")
-def pdaf_set_memberid(memberid: int) -> dict:
-    """
-    Set the ensemble member index to a given value.
-    
-    Args:
-        memberid: Index in the local ensemble
-    
-    Returns:
-        dict: A dictionary containing:
-            - memberid: The set member index
-    """
-    try:
-        result = PDAF.set_memberid(memberid)
-        return {"success": True, "result": {"memberid": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_set_seedset", description="Choose a seedset for the random number generator")
-def pdaf_set_seedset(seedset_in: int) -> dict:
-    """
-    Choose a seedset for the random number generator used in PDAF.
-    
-    Args:
-        seedset_in: Seedset index (1-20)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAF.set_seedset(seedset_in)
-        return {"success": True, "result": f"Seedset set to {seedset_in}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_get_obsmemberid", description="Get ensemble member ID when observation operator is applied")
-def pdaf_get_obsmemberid(memberid: int = 0) -> dict:
-    """
-    Return the ensemble member ID when observation operator is being applied.
-    
-    This function is used specifically for user-supplied function py__obs_op_pdaf.
-    
-    Args:
-        memberid: Input member ID (can be any value)
-    
-    Returns:
-        dict: A dictionary containing:
-            - memberid: Index in the local ensemble
-    """
-    try:
-        result = PDAF.get_obsmemberid(memberid)
-        return {"success": True, "result": {"memberid": int(result)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_local_weights", description="Get a vector of localization weights for given distances")
-def pdaf_local_weights(
-    wtype: int,
-    cradius: float,
-    sradius: float,
-    dim: int,
-    distance: List[float],
-    verbose: int
-) -> dict:
-    """
-    Get a vector of localization weights for given distances.
-    
-    This is a vectorized version of pdaf_local_weight without regulation.
-    
-    Args:
-        wtype: Type of weight function:
-               0: unit weight (weight=1 up to distance=cradius)
-               1: exponential decrease (weight=1/e at distance=sradius)
-               2: 5th order polynomial (Gaspari and Cohn 1999)
-        cradius: Cut-off radius where weight=0 beyond it
-        sradius: Support radius of localization function
-        dim: Size of distance and weight arrays
-        distance: Array of distances to observations (list of length dim)
-        verbose: Verbosity flag
-    
-    Returns:
-        dict: A dictionary containing:
-            - weights: Array of localization weights (list of length dim)
-    """
-    try:
-        distance_np = np.array(distance, dtype=np.float64)
-        weights = PDAF.local_weights(wtype, cradius, sradius, dim, distance_np, verbose)
-        return {"success": True, "result": {"weights": weights.tolist()}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_diag_crps_nompi", description="Compute Continuous Ranked Probability Score without MPI")
-def pdaf_diag_crps_nompi(
-    dim: int,
-    dim_ens: int,
-    element: int,
-    oens: List[List[float]],
-    obs: List[float]
-) -> dict:
-    """
-    Obtain a Continuous Ranked Probability Score (CRPS) for an ensemble without MPI.
-    
-    Based on Hersbach (2000) decomposition of CRPS.
-    
-    Args:
-        dim: Dimension of state vector
-        dim_ens: Ensemble size
-        element: ID of element to be used (0 for mean over all elements)
-        oens: State ensemble (2D list of shape [dim, dim_ens])
-        obs: Observation/true state (list of length dim)
-    
-    Returns:
-        dict: A dictionary containing:
-            - CRPS: Continuous Ranked Probability Score
-            - reli: Reliability
-            - resol: Resolution
-            - uncert: Uncertainty
-            - status: Status flag (0=success)
-    """
-    try:
-        oens_np = np.array(oens, dtype=np.float64)
-        obs_np = np.array(obs, dtype=np.float64)
-        
-        crps, reli, resol, uncert, status = PDAF.diag_crps_nompi(
-            dim, dim_ens, element, oens_np, obs_np
-        )
-        return {
-            "success": True,
-            "result": {
-                "CRPS": float(crps),
-                "reli": float(reli),
-                "resol": float(resol),
-                "uncert": float(uncert),
-                "status": int(status)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdaf_diag_compute_moments", description="Compute statistical moments from an ensemble")
-def pdaf_diag_compute_moments(
-    dim_p: int,
-    dim_ens: int,
-    ens: List[List[float]],
-    kmax: int,
-    bias: int
-) -> dict:
-    """
-    Compute the mean, variance, skewness, and excess kurtosis from an ensemble.
-    
-    Args:
-        dim_p: PE-local state dimension
-        dim_ens: Ensemble size
-        ens: State ensemble (2D list of shape [dim_p, dim_ens])
-        kmax: Maximum moment to compute (1=mean, 2=variance, 3=skewness, 4=kurtosis)
-        bias: 0 for unbiased estimates, 1 for biased estimates
-    
-    Returns:
-        dict: A dictionary containing:
-            - moments: Array of moments (shape [kmax, dim_p])
-    """
-    try:
-        ens_np = np.array(ens, dtype=np.float64)
-        moments = PDAF.diag_compute_moments(dim_p, dim_ens, ens_np, kmax, bias)
-        return {"success": True, "result": {"moments": moments.tolist()}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# ============================================================================
-# Additional PDAFomi Setter Functions
-# ============================================================================
-
-@mcp.tool(name="pdafomi_set_inno_omit", description="Set innovation threshold for removing observation outliers")
-def pdafomi_set_inno_omit(i_obs: int, inno_omit: float) -> dict:
-    """
-    Set innovation threshold for removing observation outliers.
-    
-    By default, no observations are omitted. Observation omission is only
-    activated when inno_omit > 0.0. PDAF will omit observations where
-    the squared innovation of the ensemble mean is larger than the product
-    of inno_omit and observation error variance.
-    
-    Args:
-        i_obs: Index of observation type
-        inno_omit: Threshold of innovation to be omitted
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_inno_omit(i_obs, inno_omit)
-        return {"success": True, "result": f"Observation type {i_obs} inno_omit set to {inno_omit}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_set_inno_omit_ivar", description="Set inverse variance for omitted observations")
-def pdafomi_set_inno_omit_ivar(i_obs: int, inno_omit_ivar: float) -> dict:
-    """
-    Set the inverse of observation error variance for omitted observations.
-    
-    This should be set to a very small value relative to assimilated observations.
-    By default, it is set to 1e-12.
-    
-    Args:
-        i_obs: Index of observation type
-        inno_omit_ivar: Inverse of observation variance for omitted observations
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_inno_omit_ivar(i_obs, inno_omit_ivar)
-        return {"success": True, "result": f"Observation type {i_obs} inno_omit_ivar set to {inno_omit_ivar}", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_set_domainsize", description="Set domain size for observation type")
-def pdafomi_set_domainsize(i_obs: int, domainsize: List[float]) -> dict:
-    """
-    Set the domain size for periodic boundary conditions.
-    
-    This is used when disttype is set to periodic distance calculation.
-    
-    Args:
-        i_obs: Index of observation type
-        domainsize: Domain size array (list of floats)
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        domainsize_np = np.array(domainsize, dtype=np.float64)
-        PDAFomi.set_domainsize(i_obs, domainsize_np)
-        return {"success": True, "result": f"Observation type {i_obs} domainsize set", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_set_name", description="Set the name of an observation type")
-def pdafomi_set_name(i_obs: int, name: str) -> dict:
-    """
-    Set the name identifier for an observation type.
-    
-    This name is used in diagnostic output to identify the observation type.
-    
-    Args:
-        i_obs: Index of observation type
-        name: Name string for the observation type
-    
-    Returns:
-        dict: A dictionary containing the success status.
-    """
-    try:
-        PDAFomi.set_name(i_obs, name)
-        return {"success": True, "result": f"Observation type {i_obs} name set to '{name}'", "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_get_obs", description="Get observation vector and coordinates for an observation type")
-def pdafomi_diag_get_obs(id_obs: int) -> dict:
-    """
-    Get observation vector and corresponding coordinates for specified observation type.
-    
-    Args:
-        id_obs: Index of observation type to return
-    
-    Returns:
-        dict: A dictionary containing:
-            - dim_obs_diag: Observation dimension
-            - ncoord: Number of observation dimensions
-            - obs_p: Observation vector
-            - ocoord_p: Coordinate array
-    """
-    try:
-        dim_obs_diag, ncoord, obs_p, ocoord_p = PDAFomi.diag_get_obs(id_obs)
-        return {
-            "success": True,
-            "result": {
-                "dim_obs_diag": int(dim_obs_diag),
-                "ncoord": int(ncoord),
-                "obs_p": obs_p.tolist(),
-                "ocoord_p": ocoord_p.tolist()
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_get_hxmean", description="Get observed ensemble mean for an observation type")
-def pdafomi_diag_get_hxmean(id_obs: int) -> dict:
-    """
-    Get observed ensemble mean for a given observation type.
-    
-    Args:
-        id_obs: Index of observation type to return
-    
-    Returns:
-        dict: A dictionary containing:
-            - dim_obs_diag: Observation dimension
-            - hxmean_p: Observed ensemble mean
-    """
-    try:
-        dim_obs_diag, hxmean_p = PDAFomi.diag_get_hxmean(id_obs)
-        return {
-            "success": True,
-            "result": {
-                "dim_obs_diag": int(dim_obs_diag),
-                "hxmean_p": hxmean_p.tolist()
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="pdafomi_diag_get_ivar", description="Get inverse observation error variance for an observation type")
-def pdafomi_diag_get_ivar(id_obs: int) -> dict:
-    """
-    Get inverse of observation error variance for a given observation type.
-    
-    Args:
-        id_obs: Index of observation type to return
-    
-    Returns:
-        dict: A dictionary containing:
-            - dim_obs_diag: Observation dimension
-            - ivar: Inverse observation error variances
-    """
-    try:
-        dim_obs_diag, ivar = PDAFomi.diag_get_ivar(id_obs)
-        return {
-            "success": True,
-            "result": {
-                "dim_obs_diag": int(dim_obs_diag),
-                "ivar": ivar.tolist()
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# ============================================================================
-# Utility Functions
-# ============================================================================
-
-@mcp.tool(name="get_pdaf_module_info", description="Get information about available pyPDAF modules and their functions")
-def get_pdaf_module_info() -> dict:
-    """
-    Get information about available pyPDAF modules and their main functions.
-    
-    Returns:
-        dict: A dictionary containing module information.
-    """
-    try:
-        info = {
-            "PDAF": {
-                "description": "Core PDAF module with filter functions and utilities",
-                "main_functions": [
-                    "correlation_function", "deallocate", "eofcovar", "force_analysis",
-                    "get_fcst_info", "print_filter_types", "print_da_types", "print_info",
-                    "reset_forget", "set_debug_flag", "set_offline_mode", "sample_ens",
-                    "local_weight", "local_weights", "set_ens_pointer",
-                    "get_assim_flag", "get_localfilter", "get_local_type", "get_memberid",
-                    "diag_ensmean", "diag_stddev_nompi", "diag_stddev",
-                    "diag_variance_nompi", "diag_variance",
-                    "diag_rmsd_nompi", "diag_rmsd",
-                    "diag_effsample", "diag_ensstats", "diag_compute_moments"
-                ]
-            },
-            "PDAF3": {
-                "description": "PDAF3 module with initialization and assimilation functions",
-                "main_functions": [
-                    "init", "init_forecast", "set_parallel",
-                    "assimilate", "assim_offline",
-                    "assimilate_3dvar_all", "assim_offline_3dvar_all",
-                    "assimilate_local_nondiagr", "assimilate_global_nondiagr",
-                    "generate_obs", "generate_obs_offline"
-                ]
-            },
-            "PDAFomi": {
-                "description": "PDAF Observation Module Interface for flexible observation handling",
-                "main_functions": [
-                    "init", "init_local", "check_error", "gather_obs",
-                    "set_debug_flag", "set_doassim", "set_disttype", "set_ncoord",
-                    "set_obs_err_type", "set_use_global_obs",
-                    "set_inno_omit", "set_inno_omit_ivar",
-                    "diag_nobstypes", "diag_dimobs", "diag_obs_rmsd", "diag_stats",
-                    "diag_get_hx", "diag_get_hxmean", "diag_get_obs"
-                ]
-            },
-            "PDAFlocal": {
-                "description": "PDAF local analysis module for domain localization",
-                "main_functions": [
-                    "set_indices", "set_increment_weights", "clear_increment_weights"
-                ]
-            },
-            "PDAFlocalomi": {
-                "description": "PDAF local analysis with OMI observation handling",
-                "main_functions": []
-            }
-        }
-        return {"success": True, "result": info, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-def create_app() -> FastMCP:
-    """
-    Creates and returns the FastMCP application instance.
-    
-    Returns:
-        FastMCP: The FastMCP application instance.
-    """
-    return mcp
+def create_app():
+    """Create and return the FastMCP application."""
+    return mcp