Update SPM/mcp_output/mcp_plugin/mcp_service.py

SPM/mcp_output/mcp_plugin/mcp_service.py

@@ -14,7 +14,7 @@ mcp = FastMCP("sequence_pattern_matching_service")
 @mcp.tool(name="sequence_pattern_matching", description="Perform sequence pattern matching for target protein alignment")
 def sequence_pattern_matching(input_sequence: str, target_sequence: str) -> dict:
     """
-    Perform sequence pattern matching for target protein alignment.
+    Perform sequence pattern matching for target protein alignment using the real SPM algorithm.
 
     Parameters:
         input_sequence (str): The input sequence to be matched.
@@ -28,37 +28,101 @@ def sequence_pattern_matching(input_sequence: str, target_sequence: str) -> dict
         
         import numpy as np
         
-        # Convert sequences to volume arrays
+        # Convert sequences to volume arrays using the real volume dictionary from SPM
         query_seq_volume = np.array([volume[i] for i in input_sequence])
         
-        # Calculate the best match score and position
-        query_len = len(query_seq_volume)
-        db_seq_volume = np.array([volume[i] for i in target_sequence])
+        # Use the real volumeScoring function from SPM
+        # Create a mock uniprot_info for the target sequence
+        uniprot_info = f">target_sequence|length_{len(target_sequence)}"
         
-        best_score = 9999
-        best_position = 0
+        # Call the real volumeScoring function
+        result_data = volumeScoring(query_seq_volume, uniprot_info, target_sequence)
         
-        for i in range(len(db_seq_volume) - query_len + 1):
-            score = np.sum(np.abs(db_seq_volume[i:i+query_len] - query_seq_volume))
-            if score < best_score:
-                best_score = score
-                best_position = i
+        # Extract results
+        best_score = result_data[1]  # score
+        best_position = result_data[2]  # position (0-indexed)
         
-        # Create result
+        # Get the matched region
+        query_len = len(input_sequence)
+        matched_region = target_sequence[best_position:best_position + query_len]
+        
+        # Create comprehensive result
         result = {
             "input_sequence": input_sequence,
-            "target_sequence": target_sequence[:100] + "..." if len(target_sequence) > 100 else target_sequence,
+            "target_sequence_preview": target_sequence[:100] + "..." if len(target_sequence) > 100 else target_sequence,
             "best_score": float(best_score),
             "best_position": int(best_position),
-            "matched_region": target_sequence[best_position:best_position + query_len],
+            "matched_region": matched_region,
             "query_length": query_len,
-            "target_length": len(target_sequence)
+            "target_length": len(target_sequence),
+            "uniprot_info": result_data[0],
+            "volume_difference": float(best_score),
+            "algorithm": "SPM Volume-based Pattern Matching"
         }
 
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
 
+@mcp.tool(name="spm_database_search", description="Search query sequence against a FASTA database using SPM algorithm")
+def spm_database_search(query_sequence: str, database_sequences: list) -> dict:
+    """
+    Search query sequence against multiple database sequences using SPM algorithm.
+    
+    Parameters:
+        query_sequence (str): The query sequence to search for.
+        database_sequences (list): List of dictionaries with 'name' and 'sequence' keys.
+    
+    Returns:
+        dict: A dictionary containing success, result, or error fields.
+    """
+    try:
+        from scripts.SequencePatternMatching import volumeScoring, volume
+        
+        import numpy as np
+        
+        # Convert query sequence to volume array
+        query_seq_volume = np.array([volume[i] for i in query_sequence])
+        
+        # Perform search against all database sequences
+        results = []
+        
+        for db_entry in database_sequences:
+            name = db_entry.get('name', 'unknown')
+            sequence = db_entry.get('sequence', '')
+            
+            if not sequence:
+                continue
+                
+            # Use the real volumeScoring function
+            result_data = volumeScoring(query_seq_volume, name, sequence)
+            
+            results.append({
+                'name': result_data[0],
+                'score': float(result_data[1]),
+                'position': int(result_data[2]),
+                'matched_region': sequence[result_data[2]:result_data[2] + len(query_sequence)],
+                'sequence_length': len(sequence)
+            })
+        
+        # Sort results by score (lower is better)
+        results.sort(key=lambda x: x['score'])
+        
+        return {
+            "success": True, 
+            "result": {
+                "query_sequence": query_sequence,
+                "total_searched": len(database_sequences),
+                "total_matches": len(results),
+                "top_matches": results[:10],  # Top 10 matches
+                "best_match": results[0] if results else None
+            }, 
+            "error": None
+        }
+        
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
 # Create the application
 def create_app() -> FastMCP:
     """