mock cudaq

Signed-off-by: ale <ale@manalejandro.com>

python/cudaq_bridge.py

@@ -21,8 +21,8 @@ try:
     logger.info("CUDA Quantum successfully imported")
 except ImportError as e:
     CUDAQ_AVAILABLE = False
-    logger.error(f"CUDA Quantum not available: {e}")
-    logger.error("Please install CUDA Quantum: pip install cudaq")
+    logger.warning(f"CUDA Quantum not available: {e}")
+    logger.warning("Running in mock mode - install CUDA Quantum for full functionality: pip install cudaq")
 
 
 class QuantumKernelManager:
@@ -35,7 +35,13 @@ class QuantumKernelManager:
     def create_kernel(self, name: str, num_qubits: int, parameters: Optional[List[Dict]] = None) -> Dict:
         """Create a new quantum kernel"""
         if not CUDAQ_AVAILABLE:
-            return {"error": "CUDA Quantum not available"}
+            # Mock mode - store kernel metadata without actual CUDA Quantum
+            self.kernel_metadata[name] = {
+                "num_qubits": num_qubits,
+                "parameters": parameters or [],
+                "operations": []
+            }
+            return {"success": True, "kernel_name": name, "mode": "mock"}
             
         try:
             # Create kernel dynamically
@@ -216,7 +222,31 @@ class QuantumExecutor:
                parameters: Optional[Dict] = None) -> Dict:
         """Sample measurement results from quantum kernel"""
         if not CUDAQ_AVAILABLE:
-            return {"error": "CUDA Quantum not available"}
+            # Mock mode - return simulated results
+            if kernel_name not in self.kernel_manager.kernel_metadata:
+                return {"error": f"Kernel {kernel_name} not found"}
+            
+            import random
+            num_qubits = self.kernel_manager.kernel_metadata[kernel_name]["num_qubits"]
+            
+            # Generate mock results for demonstration
+            mock_counts = {}
+            if num_qubits == 2:  # Bell pair example
+                mock_counts = {"00": shots//2 + random.randint(-50, 50), 
+                             "11": shots//2 + random.randint(-50, 50)}
+            else:
+                # Random distribution
+                for i in range(min(4, 2**num_qubits)):
+                    binary = format(i, f'0{num_qubits}b')
+                    mock_counts[binary] = random.randint(shots//10, shots//3)
+            
+            return {
+                "success": True,
+                "counts": mock_counts,
+                "shots": shots,
+                "total_counts": sum(mock_counts.values()),
+                "mode": "mock"
+            }
             
         if kernel_name not in self.kernel_manager.kernels:
             return {"error": f"Kernel {kernel_name} not found"}
@@ -459,24 +489,30 @@ def main():
         except Exception as e:
             print(json.dumps({"error": str(e), "traceback": traceback.format_exc()}))
     else:
-        # Interactive mode
-        print("CUDA Quantum Python Bridge - Interactive Mode")
-        print("Available commands: create_kernel, apply_gate, set_target, sample, observe, get_state")
+        # Server mode - read from stdin for MCP communication
+        print("CUDA Quantum Python Bridge - Ready")
+        sys.stdout.flush()
         
-        while True:
-            try:
-                command_line = input("> ")
-                if command_line.lower() in ["quit", "exit"]:
+        try:
+            while True:
+                line = sys.stdin.readline()
+                if not line:
                     break
                 
-                command_data = json.loads(command_line)
-                result = dispatch_command(**command_data)
-                print(json.dumps(result, indent=2))
-                
-            except KeyboardInterrupt:
-                break
-            except Exception as e:
-                print(json.dumps({"error": str(e)}))
+                try:
+                    command_data = json.loads(line.strip())
+                    result = dispatch_command(**command_data)
+                    print(json.dumps(result))
+                    sys.stdout.flush()
+                except json.JSONDecodeError:
+                    print(json.dumps({"error": "Invalid JSON"}))
+                    sys.stdout.flush()
+                except Exception as e:
+                    print(json.dumps({"error": str(e)}))
+                    sys.stdout.flush()
+                    
+        except KeyboardInterrupt:
+            pass
 
 
 if __name__ == "__main__":