Update qutip/mcp_output/mcp_plugin/mcp_service.py

qutip/mcp_output/mcp_plugin/mcp_service.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from typing import List, Optional
 
 # 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")
@@ -7,45 +8,912 @@ if source_path not in sys.path:
     sys.path.insert(0, source_path)
 
 from fastmcp import FastMCP
-from qutip.visualization import plot_wigner, plot_fock_distribution
+import numpy as np
+
+# Import QuTiP modules
+from qutip import (
+    # States
+    basis, fock, fock_dm, coherent, coherent_dm, thermal_dm,
+    ket2dm, bell_state, ghz_state, w_state, spin_state, spin_coherent,
+    # Operators
+    destroy, create, num, qeye, sigmax, sigmay, sigmaz, sigmap, sigmam,
+    jmat, squeeze, displace, qdiags,
+    # Tensor operations
+    tensor, expect, variance,
+    # Metrics
+    fidelity, tracedist,
+    # Entropy
+    entropy_vn, entropy_linear, concurrence, negativity,
+    # Wigner
+    wigner, qfunc,
+    # Random
+    rand_ket, rand_dm, rand_unitary, rand_herm,
+    # Visualization
+    Qobj,
+)
+from qutip.visualization import (
+    plot_wigner, plot_fock_distribution, hinton, matrix_histogram,
+    plot_energy_levels, plot_expectation_values
+)
 
 # Create the FastMCP service application
-mcp = FastMCP("quantum_visualization_service")
+mcp = FastMCP("qutip_quantum_service")
+
+
+# ==================== Quantum States ====================
+
+@mcp.tool(name="create_basis_state", description="Create a Fock state |n> in an N-dimensional Hilbert space.")
+def create_basis_state(N: int, n: int = 0) -> dict:
+    """
+    Creates a Fock state (number state) |n> in an N-dimensional Hilbert space.
+
+    Parameters:
+    - N (int): Number of basis states in the Hilbert space.
+    - n (int): The number state index (default: 0 for ground state).
+
+    Returns:
+    - dict: Contains the state data or error message.
+    """
+    try:
+        state = basis(N, n)
+        return {
+            "success": True,
+            "state_type": state.type,
+            "dims": str(state.dims),
+            "shape": str(state.shape),
+            "data": state.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_coherent_state", description="Create a coherent state with eigenvalue alpha.")
+def create_coherent_state(N: int, alpha_real: float, alpha_imag: float = 0.0) -> dict:
+    """
+    Creates a coherent state |alpha> in an N-dimensional Hilbert space.
+
+    Parameters:
+    - N (int): Number of Fock states in Hilbert space.
+    - alpha_real (float): Real part of the coherent state eigenvalue.
+    - alpha_imag (float): Imaginary part of the coherent state eigenvalue.
+
+    Returns:
+    - dict: Contains the state data or error message.
+    """
+    try:
+        alpha = complex(alpha_real, alpha_imag)
+        state = coherent(N, alpha)
+        return {
+            "success": True,
+            "alpha": str(alpha),
+            "state_type": state.type,
+            "dims": str(state.dims),
+            "shape": str(state.shape),
+            "mean_photon_number": float(expect(num(N), state).real)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_thermal_state", description="Create a thermal density matrix with given average photon number.")
+def create_thermal_state(N: int, n_avg: float) -> dict:
+    """
+    Creates a thermal state density matrix.
+
+    Parameters:
+    - N (int): Number of basis states in Hilbert space.
+    - n_avg (float): Average photon number (temperature parameter).
+
+    Returns:
+    - dict: Contains the state data or error message.
+    """
+    try:
+        state = thermal_dm(N, n_avg)
+        return {
+            "success": True,
+            "n_avg": n_avg,
+            "state_type": state.type,
+            "dims": str(state.dims),
+            "shape": str(state.shape),
+            "purity": float((state * state).tr().real)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_bell_state", description="Create a Bell state for two qubits.")
+def create_bell_state(state_type: str = "00") -> dict:
+    """
+    Creates one of the four Bell states.
+
+    Parameters:
+    - state_type (str): Type of Bell state - "00", "01", "10", or "11".
+
+    Returns:
+    - dict: Contains the state data or error message.
+    """
+    try:
+        state = bell_state(state_type)
+        return {
+            "success": True,
+            "bell_state_type": state_type,
+            "state_type": state.type,
+            "dims": str(state.dims),
+            "shape": str(state.shape),
+            "data": state.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_ghz_state", description="Create a GHZ (Greenberger-Horne-Zeilinger) state for N qubits.")
+def create_ghz_state(N: int) -> dict:
+    """
+    Creates a GHZ state for N qubits: (|00...0> + |11...1>)/sqrt(2).
+
+    Parameters:
+    - N (int): Number of qubits.
+
+    Returns:
+    - dict: Contains the state data or error message.
+    """
+    try:
+        state = ghz_state(N)
+        return {
+            "success": True,
+            "n_qubits": N,
+            "state_type": state.type,
+            "dims": str(state.dims),
+            "shape": str(state.shape)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_spin_coherent_state", description="Create a spin coherent state.")
+def create_spin_coherent_state(j: float, theta: float, phi: float) -> dict:
+    """
+    Creates a spin coherent state.
+
+    Parameters:
+    - j (float): Spin quantum number (e.g., 0.5, 1, 1.5, ...).
+    - theta (float): Polar angle (0 to pi).
+    - phi (float): Azimuthal angle (0 to 2*pi).
+
+    Returns:
+    - dict: Contains the state data or error message.
+    """
+    try:
+        state = spin_coherent(j, theta, phi)
+        return {
+            "success": True,
+            "j": j,
+            "theta": theta,
+            "phi": phi,
+            "state_type": state.type,
+            "dims": str(state.dims),
+            "shape": str(state.shape)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Quantum Operators ====================
+
+@mcp.tool(name="create_annihilation_operator", description="Create a bosonic annihilation (lowering) operator.")
+def create_annihilation_operator(N: int) -> dict:
+    """
+    Creates a destruction (annihilation) operator for an N-dimensional Hilbert space.
+
+    Parameters:
+    - N (int): Number of basis states in Hilbert space.
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        op = destroy(N)
+        return {
+            "success": True,
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_hermitian": bool(op.isherm),
+            "data": op.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_creation_operator", description="Create a bosonic creation (raising) operator.")
+def create_creation_operator(N: int) -> dict:
+    """
+    Creates a creation (raising) operator for an N-dimensional Hilbert space.
+
+    Parameters:
+    - N (int): Number of basis states in Hilbert space.
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        op = create(N)
+        return {
+            "success": True,
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_hermitian": bool(op.isherm),
+            "data": op.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_number_operator", description="Create a photon number operator.")
+def create_number_operator(N: int) -> dict:
+    """
+    Creates a number operator for an N-dimensional Hilbert space.
+
+    Parameters:
+    - N (int): Number of basis states in Hilbert space.
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        op = num(N)
+        return {
+            "success": True,
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_hermitian": bool(op.isherm),
+            "data": op.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_pauli_operator", description="Create a Pauli spin-1/2 operator (x, y, or z).")
+def create_pauli_operator(which: str) -> dict:
+    """
+    Creates a Pauli spin-1/2 operator.
+
+    Parameters:
+    - which (str): Which Pauli operator - "x", "y", or "z".
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        if which.lower() == "x":
+            op = sigmax()
+        elif which.lower() == "y":
+            op = sigmay()
+        elif which.lower() == "z":
+            op = sigmaz()
+        else:
+            return {"success": False, "error": "Invalid Pauli operator. Use 'x', 'y', or 'z'."}
+        
+        return {
+            "success": True,
+            "pauli_type": which,
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_hermitian": bool(op.isherm),
+            "data": op.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_spin_operator", description="Create a spin-j operator (Jx, Jy, Jz, J+, or J-).")
+def create_spin_operator(j: float, which: str) -> dict:
+    """
+    Creates a spin-j angular momentum operator.
+
+    Parameters:
+    - j (float): Spin quantum number (e.g., 0.5, 1, 1.5, ...).
+    - which (str): Which operator - "x", "y", "z", "+", or "-".
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        op = jmat(j, which)
+        return {
+            "success": True,
+            "j": j,
+            "which": which,
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_hermitian": bool(op.isherm),
+            "data": op.full().tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_displacement_operator", description="Create a displacement operator for coherent states.")
+def create_displacement_operator(N: int, alpha_real: float, alpha_imag: float = 0.0) -> dict:
+    """
+    Creates a displacement operator D(alpha).
+
+    Parameters:
+    - N (int): Number of Fock states in Hilbert space.
+    - alpha_real (float): Real part of displacement amplitude.
+    - alpha_imag (float): Imaginary part of displacement amplitude.
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        alpha = complex(alpha_real, alpha_imag)
+        op = displace(N, alpha)
+        return {
+            "success": True,
+            "alpha": str(alpha),
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_unitary": bool(op.isunitary)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_squeeze_operator", description="Create a squeezing operator.")
+def create_squeeze_operator(N: int, z_real: float, z_imag: float = 0.0) -> dict:
+    """
+    Creates a squeezing operator S(z).
+
+    Parameters:
+    - N (int): Number of Fock states in Hilbert space.
+    - z_real (float): Real part of squeezing parameter.
+    - z_imag (float): Imaginary part of squeezing parameter.
+
+    Returns:
+    - dict: Contains the operator data or error message.
+    """
+    try:
+        z = complex(z_real, z_imag)
+        op = squeeze(N, z)
+        return {
+            "success": True,
+            "z": str(z),
+            "operator_type": op.type,
+            "dims": str(op.dims),
+            "shape": str(op.shape),
+            "is_unitary": bool(op.isunitary)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Measurements & Expectations ====================
+
+@mcp.tool(name="calculate_expectation_value", description="Calculate the expectation value of an operator for a given state.")
+def calculate_expectation_value(N: int, state_n: int, operator_type: str) -> dict:
+    """
+    Calculates the expectation value <state|operator|state>.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state_n (int): Fock state index.
+    - operator_type (str): Type of operator - "number", "x", "p" (position/momentum for harmonic oscillator).
+
+    Returns:
+    - dict: Contains the expectation value or error message.
+    """
+    try:
+        state = basis(N, state_n)
+        
+        if operator_type == "number":
+            op = num(N)
+        elif operator_type == "x":
+            # Position operator: x = (a + a†) / sqrt(2)
+            a = destroy(N)
+            op = (a + a.dag()) / np.sqrt(2)
+        elif operator_type == "p":
+            # Momentum operator: p = i(a† - a) / sqrt(2)
+            a = destroy(N)
+            op = 1j * (a.dag() - a) / np.sqrt(2)
+        else:
+            return {"success": False, "error": "Invalid operator type. Use 'number', 'x', or 'p'."}
+        
+        exp_val = expect(op, state)
+        return {
+            "success": True,
+            "state": f"|{state_n}>",
+            "operator": operator_type,
+            "expectation_value": complex(exp_val).real if np.isreal(exp_val) else str(exp_val)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="calculate_photon_statistics", description="Calculate photon number statistics for a quantum state.")
+def calculate_photon_statistics(N: int, state_type: str, param: float) -> dict:
+    """
+    Calculates photon number statistics (mean, variance, Fano factor) for a quantum state.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state_type (str): Type of state - "fock", "coherent", or "thermal".
+    - param (float): State parameter (n for Fock, |alpha| for coherent, n_avg for thermal).
+
+    Returns:
+    - dict: Contains photon statistics or error message.
+    """
+    try:
+        if state_type == "fock":
+            state = basis(N, int(param))
+        elif state_type == "coherent":
+            state = coherent(N, param)
+        elif state_type == "thermal":
+            state = thermal_dm(N, param)
+        else:
+            return {"success": False, "error": "Invalid state type. Use 'fock', 'coherent', or 'thermal'."}
+        
+        n_op = num(N)
+        mean_n = float(expect(n_op, state).real)
+        var_n = float(variance(n_op, state).real)
+        fano_factor = var_n / mean_n if mean_n > 0 else 0
+        
+        return {
+            "success": True,
+            "state_type": state_type,
+            "mean_photon_number": mean_n,
+            "variance": var_n,
+            "fano_factor": fano_factor,
+            "statistics_type": "sub-Poissonian" if fano_factor < 1 else ("Poissonian" if abs(fano_factor - 1) < 0.01 else "super-Poissonian")
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Metrics ====================
+
+@mcp.tool(name="calculate_fidelity", description="Calculate the fidelity between two quantum states.")
+def calculate_fidelity(N: int, state1_n: int, state2_n: int) -> dict:
+    """
+    Calculates the fidelity F between two Fock states.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state1_n (int): First Fock state index.
+    - state2_n (int): Second Fock state index.
+
+    Returns:
+    - dict: Contains the fidelity value or error message.
+    """
+    try:
+        state1 = basis(N, state1_n)
+        state2 = basis(N, state2_n)
+        fid = fidelity(state1, state2)
+        return {
+            "success": True,
+            "state1": f"|{state1_n}>",
+            "state2": f"|{state2_n}>",
+            "fidelity": float(fid)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="calculate_trace_distance", description="Calculate the trace distance between two quantum states.")
+def calculate_trace_distance(N: int, state1_n: int, state2_n: int) -> dict:
+    """
+    Calculates the trace distance D between two Fock states.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state1_n (int): First Fock state index.
+    - state2_n (int): Second Fock state index.
+
+    Returns:
+    - dict: Contains the trace distance value or error message.
+    """
+    try:
+        state1 = fock_dm(N, state1_n)
+        state2 = fock_dm(N, state2_n)
+        dist = tracedist(state1, state2)
+        return {
+            "success": True,
+            "state1": f"|{state1_n}><{state1_n}|",
+            "state2": f"|{state2_n}><{state2_n}|",
+            "trace_distance": float(dist)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Entropy ====================
+
+@mcp.tool(name="calculate_von_neumann_entropy", description="Calculate the von Neumann entropy of a density matrix.")
+def calculate_von_neumann_entropy(N: int, n_thermal: float) -> dict:
+    """
+    Calculates the von Neumann entropy S = -Tr(rho * log(rho)) for a thermal state.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - n_thermal (float): Average thermal photon number.
+
+    Returns:
+    - dict: Contains the entropy value or error message.
+    """
+    try:
+        rho = thermal_dm(N, n_thermal)
+        entropy = entropy_vn(rho)
+        entropy_bits = entropy_vn(rho, base=2)
+        return {
+            "success": True,
+            "n_thermal": n_thermal,
+            "entropy_nats": float(entropy),
+            "entropy_bits": float(entropy_bits),
+            "purity": float((rho * rho).tr().real)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="calculate_linear_entropy", description="Calculate the linear entropy of a quantum state.")
+def calculate_linear_entropy(N: int, n_thermal: float) -> dict:
+    """
+    Calculates the linear entropy S_L = 1 - Tr(rho^2) for a thermal state.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - n_thermal (float): Average thermal photon number.
+
+    Returns:
+    - dict: Contains the linear entropy value or error message.
+    """
+    try:
+        rho = thermal_dm(N, n_thermal)
+        lin_entropy = entropy_linear(rho)
+        return {
+            "success": True,
+            "n_thermal": n_thermal,
+            "linear_entropy": float(lin_entropy),
+            "purity": 1 - float(lin_entropy)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="calculate_concurrence", description="Calculate the concurrence (entanglement measure) for a two-qubit state.")
+def calculate_concurrence(bell_state_type: str = "00") -> dict:
+    """
+    Calculates the concurrence for a Bell state (two-qubit entanglement measure).
+
+    Parameters:
+    - bell_state_type (str): Type of Bell state - "00", "01", "10", or "11".
+
+    Returns:
+    - dict: Contains the concurrence value or error message.
+    """
+    try:
+        state = bell_state(bell_state_type)
+        conc = concurrence(state)
+        return {
+            "success": True,
+            "bell_state_type": bell_state_type,
+            "concurrence": float(conc),
+            "is_maximally_entangled": abs(conc - 1.0) < 1e-10
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Wigner Function ====================
+
+@mcp.tool(name="calculate_wigner_function", description="Calculate the Wigner function at a point in phase space.")
+def calculate_wigner_function(N: int, state_type: str, param: float, x: float, y: float) -> dict:
+    """
+    Calculates the Wigner quasi-probability distribution W(x,p) at a point.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state_type (str): Type of state - "fock", "coherent", or "thermal".
+    - param (float): State parameter.
+    - x (float): Position coordinate.
+    - y (float): Momentum coordinate.
+
+    Returns:
+    - dict: Contains the Wigner function value or error message.
+    """
+    try:
+        if state_type == "fock":
+            state = fock_dm(N, int(param))
+        elif state_type == "coherent":
+            state = coherent_dm(N, param)
+        elif state_type == "thermal":
+            state = thermal_dm(N, param)
+        else:
+            return {"success": False, "error": "Invalid state type."}
+        
+        xvec = np.array([x])
+        yvec = np.array([y])
+        W = wigner(state, xvec, yvec)
+        
+        return {
+            "success": True,
+            "state_type": state_type,
+            "x": x,
+            "y": y,
+            "wigner_value": float(W[0, 0])
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="calculate_q_function", description="Calculate the Husimi Q function at a point in phase space.")
+def calculate_q_function(N: int, state_type: str, param: float, x: float, y: float) -> dict:
+    """
+    Calculates the Husimi Q quasi-probability distribution Q(alpha) at a point.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state_type (str): Type of state - "fock", "coherent", or "thermal".
+    - param (float): State parameter.
+    - x (float): Real part of alpha.
+    - y (float): Imaginary part of alpha.
+
+    Returns:
+    - dict: Contains the Q function value or error message.
+    """
+    try:
+        if state_type == "fock":
+            state = fock_dm(N, int(param))
+        elif state_type == "coherent":
+            state = coherent_dm(N, param)
+        elif state_type == "thermal":
+            state = thermal_dm(N, param)
+        else:
+            return {"success": False, "error": "Invalid state type."}
+        
+        xvec = np.array([x])
+        yvec = np.array([y])
+        Q = qfunc(state, xvec, yvec)
+        
+        return {
+            "success": True,
+            "state_type": state_type,
+            "x": x,
+            "y": y,
+            "q_value": float(Q[0, 0])
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Random States ====================
+
+@mcp.tool(name="generate_random_ket", description="Generate a random pure state (ket).")
+def generate_random_ket(N: int, seed: Optional[int] = None) -> dict:
+    """
+    Generates a random normalized ket vector.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - seed (int, optional): Random seed for reproducibility.
+
+    Returns:
+    - dict: Contains the random state information or error message.
+    """
+    try:
+        state = rand_ket(N, seed=seed)
+        return {
+            "success": True,
+            "dimension": N,
+            "state_type": state.type,
+            "norm": float(state.norm()),
+            "dims": str(state.dims)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="generate_random_density_matrix", description="Generate a random density matrix.")
+def generate_random_density_matrix(N: int, pure: bool = False, seed: Optional[int] = None) -> dict:
+    """
+    Generates a random density matrix.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - pure (bool): If True, generates a pure state density matrix.
+    - seed (int, optional): Random seed for reproducibility.
+
+    Returns:
+    - dict: Contains the random density matrix information or error message.
+    """
+    try:
+        rho = rand_dm(N, pure=pure, seed=seed)
+        purity = float((rho * rho).tr().real)
+        return {
+            "success": True,
+            "dimension": N,
+            "is_pure": pure,
+            "trace": float(rho.tr().real),
+            "purity": purity,
+            "von_neumann_entropy": float(entropy_vn(rho))
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="generate_random_unitary", description="Generate a random unitary operator.")
+def generate_random_unitary(N: int, seed: Optional[int] = None) -> dict:
+    """
+    Generates a random unitary operator from the Haar measure.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - seed (int, optional): Random seed for reproducibility.
+
+    Returns:
+    - dict: Contains the random unitary information or error message.
+    """
+    try:
+        U = rand_unitary(N, seed=seed)
+        # Check unitarity: U†U = I
+        identity_check = (U.dag() * U - qeye(N)).norm()
+        return {
+            "success": True,
+            "dimension": N,
+            "is_unitary": identity_check < 1e-10,
+            "unitarity_error": float(identity_check)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Tensor Products ====================
+
+@mcp.tool(name="tensor_product_states", description="Create a tensor product of multiple Fock states.")
+def tensor_product_states(dimensions: List[int], states: List[int]) -> dict:
+    """
+    Creates a tensor product of Fock states.
+
+    Parameters:
+    - dimensions (list): List of Hilbert space dimensions for each subsystem.
+    - states (list): List of Fock state indices for each subsystem.
+
+    Returns:
+    - dict: Contains the tensor product state information or error message.
+    """
+    try:
+        if len(dimensions) != len(states):
+            return {"success": False, "error": "dimensions and states must have the same length."}
+        
+        kets = [basis(d, n) for d, n in zip(dimensions, states)]
+        product_state = tensor(kets)
+        
+        return {
+            "success": True,
+            "subsystem_dims": dimensions,
+            "subsystem_states": states,
+            "total_dimension": int(np.prod(dimensions)),
+            "result_dims": str(product_state.dims),
+            "result_shape": str(product_state.shape)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ==================== Visualization Tools ====================
 
 @mcp.tool(name="plot_wigner_tool", description="Plot the Wigner function of a quantum state.")
-def plot_wigner_tool(state: 'Qobj') -> dict:
+def plot_wigner_tool(N: int, state_type: str, param: float) -> dict:
     """
     Plots the Wigner function for a given quantum state.
 
     Parameters:
-    - state (Qobj): The quantum state for which to plot the Wigner function.
+    - N (int): Hilbert space dimension.
+    - state_type (str): Type of state - "fock", "coherent", or "thermal".
+    - param (float): State parameter.
 
     Returns:
     - dict: A dictionary containing the success status and result or error message.
     """
     try:
+        if state_type == "fock":
+            state = fock_dm(N, int(param))
+        elif state_type == "coherent":
+            state = coherent_dm(N, param)
+        elif state_type == "thermal":
+            state = thermal_dm(N, param)
+        else:
+            return {"success": False, "error": "Invalid state type."}
+        
         plot_wigner(state)
         return {"success": True, "result": "Wigner plot generated successfully."}
     except Exception as e:
         return {"success": False, "error": str(e)}
 
+
 @mcp.tool(name="plot_fock_distribution_tool", description="Plot the Fock distribution of a quantum state.")
-def plot_fock_distribution_tool(state: 'Qobj') -> dict:
+def plot_fock_distribution_tool(N: int, state_type: str, param: float) -> dict:
     """
     Plots the Fock distribution for a given quantum state.
 
     Parameters:
-    - state (Qobj): The quantum state for which to plot the Fock distribution.
+    - N (int): Hilbert space dimension.
+    - state_type (str): Type of state - "fock", "coherent", or "thermal".
+    - param (float): State parameter.
 
     Returns:
     - dict: A dictionary containing the success status and result or error message.
     """
     try:
+        if state_type == "fock":
+            state = basis(N, int(param))
+        elif state_type == "coherent":
+            state = coherent(N, param)
+        elif state_type == "thermal":
+            state = thermal_dm(N, param)
+        else:
+            return {"success": False, "error": "Invalid state type."}
+        
         plot_fock_distribution(state)
         return {"success": True, "result": "Fock distribution plot generated successfully."}
     except Exception as e:
         return {"success": False, "error": str(e)}
 
+
+@mcp.tool(name="plot_hinton_diagram", description="Plot a Hinton diagram for a density matrix.")
+def plot_hinton_diagram(N: int, n_thermal: float) -> dict:
+    """
+    Plots a Hinton diagram showing the magnitude of density matrix elements.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - n_thermal (float): Average thermal photon number.
+
+    Returns:
+    - dict: A dictionary containing the success status and result or error message.
+    """
+    try:
+        rho = thermal_dm(N, n_thermal)
+        hinton(rho)
+        return {"success": True, "result": "Hinton diagram generated successfully."}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="plot_matrix_histogram", description="Plot a 3D histogram of a density matrix.")
+def plot_matrix_histogram(N: int, state_type: str, param: float) -> dict:
+    """
+    Plots a 3D histogram of the density matrix elements.
+
+    Parameters:
+    - N (int): Hilbert space dimension.
+    - state_type (str): Type of state - "fock", "coherent", or "thermal".
+    - param (float): State parameter.
+
+    Returns:
+    - dict: A dictionary containing the success status and result or error message.
+    """
+    try:
+        if state_type == "fock":
+            rho = fock_dm(N, int(param))
+        elif state_type == "coherent":
+            rho = coherent_dm(N, param)
+        elif state_type == "thermal":
+            rho = thermal_dm(N, param)
+        else:
+            return {"success": False, "error": "Invalid state type."}
+        
+        matrix_histogram(rho)
+        return {"success": True, "result": "Matrix histogram generated successfully."}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
 def create_app() -> FastMCP:
     """
     Creates and returns the FastMCP instance for the service.