# Install via Smithery CLI
npx @smithery/cli install psi-mcp --client cursor

# Or deploy via GitHub integration
git clone https://github.com/manasp21/Psi-MCP.git
cd Psi-MCP
# Push to your GitHub repository and connect to Smithery

# Clone the repository
git clone https://github.com/manasp21/Psi-MCP.git
cd Psi-MCP

# Install dependencies
pip install -r requirements.txt

# Run the server
python src/server.py

# Build the container
docker build -t psi-mcp .

# Run with configuration
docker run -p 8000:8000 \
  -e computing_backend=simulator \
  -e max_qubits=20 \
  -e precision=double \
  psi-mcp

computing_backend: "simulator"  # qasm_simulator, statevector_simulator
max_qubits: 20                  # Maximum qubits (1-30)
precision: "double"             # single, double, extended
enable_gpu: false               # GPU acceleration
timeout_seconds: 300            # Calculation timeout
memory_limit_gb: 4              # Memory limit

PORT=8000                       # Server port
HOST=0.0.0.0                   # Server host
COMPUTING_BACKEND=simulator     # Default backend
MAX_QUBITS=20                  # Default max qubits

# Create a Bell state circuit
create_quantum_circuit(
    num_qubits=2,
    circuit_type="bell",
    backend="qasm_simulator"
)

# Create a GHZ state
create_quantum_circuit(
    num_qubits=4,
    circuit_type="ghz",
    backend="statevector_simulator"
)

# Create quantum Fourier transform
create_quantum_circuit(
    num_qubits=3,
    circuit_type="qft",
    backend="simulator"
)

# Simulate with measurements
simulate_quantum_circuit(
    circuit_definition="circuit_1",
    shots=1024,
    backend="qasm_simulator"
)

# Get statevector
simulate_quantum_circuit(
    circuit_definition="circuit_2",
    shots=1,
    backend="statevector_simulator"
)

# Optimize for specific backend
optimize_quantum_circuit(
    circuit_definition="circuit_1",
    optimization_level=2,
    target_backend="qasm_simulator"
)

# Solve Lindblad master equation
solve_master_equation(
    hamiltonian="pauli_z",
    collapse_operators="spontaneous_emission",
    initial_state="excited",
    time_span="0,10,100",
    solver_method="mesolve"
)

# Analyze decoherence
analyze_decoherence(
    system_hamiltonian="pauli_x",
    environment_coupling="dephasing",
    temperature=0.1,
    analysis_type="dephasing"
)

# Generate molecular Hamiltonian
generate_molecular_hamiltonian(
    molecule="H2",
    basis="sto-3g",
    charge=0,
    multiplicity=1
)

# Run VQE for electronic structure
vqe_chemistry(
    molecule="H2O",
    basis="6-31g",
    ansatz="uccsd",
    optimizer="cobyla"
)

# Simulate chemical reactions
simulate_chemical_reaction(
    reactants=["H2", "O2"],
    products=["H2O"],
    method="vqe"
)

# Factor integers
shors_algorithm(
    N=15,
    backend="qasm_simulator",
    shots=1024
)

# Search marked items
grovers_search(
    marked_items=[3, 7],
    search_space_size=16,
    backend="simulator"
)

# Variational quantum eigensolver
vqe_optimization(
    hamiltonian="ising",
    ansatz_type="ry",
    optimizer="cobyla",
    max_iterations=100
)

# Run DMRG for spin chains
dmrg_simulation(
    hamiltonian_type="heisenberg",
    system_size=20,
    bond_dimension=100,
    max_sweeps=10
)

# Phase transition analysis
phase_transition_analysis(
    model_type="ising",
    parameter_range=[0.0, 2.0],
    n_points=20,
    system_size=16
)

# Train quantum neural network
quantum_neural_network(
    input_data=[[0.1, 0.2], [0.3, 0.4]],
    labels=[0, 1],
    n_qubits=4,
    n_layers=2,
    epochs=50
)

# Variational classifier
variational_classifier(
    training_data=train_X,
    training_labels=train_y,
    test_data=test_X,
    ansatz_type="hardware_efficient"
)

# Bloch sphere visualization
visualize_quantum_state(
    state_definition="superposition",
    visualization_type="bloch_sphere"
)

# Density matrix plot
visualize_quantum_state(
    state_definition="bell",
    visualization_type="density_matrix"
)

# Wigner function
visualize_quantum_state(
    state_definition="coherent",
    visualization_type="wigner_function"
)

Psi-MCP/
├── src/
│   ├── server.py              # Main MCP server
│   └── quantum/               # Quantum modules
│       ├── __init__.py        # Backend initialization
│       ├── circuits.py        # Circuit operations
│       ├── systems.py         # Open quantum systems
│       ├── algorithms.py      # Quantum algorithms
│       ├── chemistry.py       # Quantum chemistry
│       ├── many_body.py       # Many-body physics
│       ├── field_theory.py    # Quantum field theory
│       ├── ml.py             # Quantum ML
│       ├── visualization.py   # Visualization tools
│       └── utils.py          # Utility functions
├── tests/                     # Test suite
├── docs/                      # Documentation
├── smithery.yaml             # Smithery configuration
├── Dockerfile               # Container configuration
├── requirements.txt         # Python dependencies
└── README.md               # This file

# 1. Create and simulate a quantum circuit
circuit_result = create_quantum_circuit(
    num_qubits=3,
    circuit_type="ghz",
    backend="qasm_simulator"
)

# 2. Simulate the circuit
simulation_result = simulate_quantum_circuit(
    circuit_definition=circuit_result['id'],
    shots=1000,
    backend="qasm_simulator"
)

# 3. Visualize the results
plot_result = plot_measurement_results(
    counts=simulation_result['counts'],
    title="GHZ State Measurement"
)

# 4. Analyze entanglement
entropy = calculate_entanglement_entropy(
    circuit_definition=circuit_result['id'],
    subsystem_size=1
)

# 1. Generate molecular Hamiltonian
hamiltonian = generate_molecular_hamiltonian(
    molecule="H2",
    basis="sto-3g"
)

# 2. Run VQE calculation
vqe_result = vqe_chemistry(
    molecule="H2",
    basis="sto-3g",
    ansatz="uccsd"
)

# 3. Compute molecular properties
properties = compute_molecular_properties(
    molecule="H2",
    method="hf",
    basis="sto-3g"
)

# Define custom spin chain
solve_master_equation(
    hamiltonian=json.dumps([[1, 0], [0, -1]]),
    collapse_operators="custom_operators",
    initial_state="custom_state"
)

# Enable GPU support
configure_server(
    enable_gpu=True,
    computing_backend="gpu_simulator"
)

# Parallel circuit simulation
simulate_circuits_parallel(
    circuit_definitions=["circuit_1", "circuit_2", "circuit_3"],
    shots=1000
)

# Clone and install development dependencies
git clone https://github.com/manasp21/Psi-MCP.git
cd Psi-MCP
pip install -r requirements.txt
pip install -e .[dev]

# Run tests
pytest tests/

# Format code
black src/ tests/
isort src/ tests/

# Type checking
mypy src/