@vespermcp/mcp-server 1.0.4 → 1.0.6

package/build/python/image_engine.py

@@ -0,0 +1,86 @@
+import sys
+import json
+import os
+from PIL import Image
+import cv2
+import numpy as np
+
+def analyze_image(image_path):
+    stats = {
+        "path": image_path,
+        "filename": os.path.basename(image_path),
+        "status": "ok",
+        "error": None
+    }
+
+    try:
+        # 1. Basic Metadata with Pillow
+        img = Image.open(image_path)
+        stats["width"], stats["height"] = img.size
+        stats["format"] = img.format
+        stats["mode"] = img.mode
+        
+        # 2. Advanced Analysis with OpenCV
+        cv_img = cv2.imread(image_path)
+        if cv_img is None:
+            stats["status"] = "corrupted"
+            stats["error"] = "OpenCV failed to decode image"
+            return stats
+
+        # Blur detection (Laplacian variance)
+        gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)
+        laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
+        stats["blur_score"] = laplacian_var
+        stats["is_blurry"] = laplacian_var < 100 # Rule of thumb threshold
+
+        # Brightness
+        stats["brightness"] = np.mean(gray)
+        
+        # Aspect Ratio
+        stats["aspect_ratio"] = stats["width"] / stats["height"]
+
+    except Exception as e:
+        stats["status"] = "failed"
+        stats["error"] = str(e)
+
+    return stats
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No path provided"}))
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    results = []
+
+    if os.path.isfile(input_path):
+        results.append(analyze_image(input_path))
+    elif os.path.isdir(input_path):
+        # Analyze first 50 images for performance in this demo
+        valid_exts = (".jpg", ".jpeg", ".png", ".bmp", ".webp")
+        files = [os.path.join(input_path, f) for f in os.listdir(input_path) if f.lower().endswith(valid_exts)]
+        for f in files[:50]:
+            results.append(analyze_image(f))
+    else:
+        print(json.dumps({"error": "Invalid path"}))
+        sys.exit(1)
+
+    # Aggregate stats
+    if not results:
+        print(json.dumps({"error": "No images found"}))
+        sys.exit(1)
+
+    report = {
+        "total_images": len(results),
+        "corrupted_count": len([r for r in results if r["status"] == "corrupted"]),
+        "failed_count": len([r for r in results if r["status"] == "failed"]),
+        "average_width": np.mean([r["width"] for r in results if "width" in r]),
+        "average_height": np.mean([r["height"] for r in results if "height" in r]),
+        "blurry_count": len([r for r in results if r.get("is_blurry")]),
+        "individual_results": results
+    }
+
+    print(json.dumps(report))
+
+if __name__ == "__main__":
+    main()

package/build/python/media_engine.py

@@ -0,0 +1,133 @@
+import sys
+import json
+import os
+import cv2
+import numpy as np
+
+# Audio analysis depends on librosa/soundfile. Fallback if not available.
+try:
+    import librosa
+    AUDIO_SUPPORT = True
+except ImportError:
+    AUDIO_SUPPORT = False
+
+def analyze_audio(path):
+    if not AUDIO_SUPPORT:
+        return {"status": "error", "error": "librosa not installed"}
+    
+    try:
+        # Load audio (mono, default sr)
+        y, sr = librosa.load(path, sr=None)
+        duration = librosa.get_duration(y=y, sr=sr)
+        
+        # Audio metrics
+        rms = librosa.feature.rms(y=y)
+        avg_rms = float(np.mean(rms))
+        
+        return {
+            "status": "ok",
+            "type": "audio",
+            "filename": os.path.basename(path),
+            "sample_rate": int(sr),
+            "duration": float(duration),
+            "avg_volume_rms": avg_rms,
+            "is_silent": avg_rms < 0.001
+        }
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def analyze_video(path):
+    try:
+        cap = cv2.VideoCapture(path)
+        if not cap.isOpened():
+            return {"status": "error", "error": "Could not open video file"}
+        
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        duration = frame_count / fps if fps > 0 else 0
+        
+        # Check integrity by reading a few frames
+        test_frame_indices = [0, frame_count // 2, frame_count - 1] if frame_count > 0 else []
+        failed_frames = 0
+        
+        for idx in test_frame_indices:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+            ret, frame = cap.read()
+            if not ret or frame is None:
+                failed_frames += 1
+        
+        cap.release()
+        
+        return {
+            "status": "ok",
+            "type": "video",
+            "filename": os.path.basename(path),
+            "width": width,
+            "height": height,
+            "fps": float(fps),
+            "duration": float(duration),
+            "frame_count": frame_count,
+            "corruption_risk": "high" if failed_frames > 0 else "low"
+        }
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No path provided"}))
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    results = []
+
+    # Supported extensions
+    AUDIO_EXTS = (".wav", ".mp3", ".flac", ".ogg", ".m4a")
+    VIDEO_EXTS = (".mp4", ".avi", ".mkv", ".mov", ".wmv")
+
+    if os.path.isfile(input_path):
+        ext = os.path.splitext(input_path.lower())[1]
+        if ext in AUDIO_EXTS:
+            results.append(analyze_audio(input_path))
+        elif ext in VIDEO_EXTS:
+            results.append(analyze_video(input_path))
+        else:
+            results.append({"status": "error", "error": f"Unsupported file type: {ext}"})
+    elif os.path.isdir(input_path):
+        files = [os.path.join(input_path, f) for f in os.listdir(input_path)]
+        for f in files[:50]: # Limit for demo
+            ext = os.path.splitext(f.lower())[1]
+            if ext in AUDIO_EXTS:
+                results.append(analyze_audio(f))
+            elif ext in VIDEO_EXTS:
+                results.append(analyze_video(f))
+    else:
+        print(json.dumps({"error": "Invalid path"}))
+        sys.exit(1)
+
+    # Filtering failed results for report aggregation
+    ok_results = [r for r in results if r.get("status") == "ok"]
+    
+    report = {
+        "total_files": len(results),
+        "ok_files": len(ok_results),
+        "failed_files": len(results) - len(ok_results),
+        "details": results
+    }
+    
+    # Calculate some averages if files were found
+    if ok_results:
+        audio_files = [r for r in ok_results if r["type"] == "audio"]
+        video_files = [r for r in ok_results if r["type"] == "video"]
+        
+        if audio_files:
+            report["avg_audio_duration"] = float(np.mean([r["duration"] for r in audio_files]))
+        if video_files:
+            report["avg_video_duration"] = float(np.mean([r["duration"] for r in video_files]))
+            report["avg_fps"] = float(np.mean([r["fps"] for r in video_files]))
+
+    print(json.dumps(report))
+
+if __name__ == "__main__":
+    main()

package/build/python/nasa_adapter.py

@@ -0,0 +1,82 @@
+import sys
+import json
+import argparse
+import urllib.request
+import urllib.parse
+from datetime import datetime
+
+# NASA Data Portal uses Socrata
+NASA_API_URL = "https://api.us.socrata.com/api/catalog/v1"
+NASA_DOMAIN = "data.nasa.gov"
+
+def search_nasa(query: str, limit: int = 10):
+    """
+    Search NASA data portal.
+    """
+    try:
+        params = {
+            "q": query,
+            "limit": limit,
+            "domains": NASA_DOMAIN,
+            "search_context": NASA_DOMAIN
+        }
+        
+        query_string = urllib.parse.urlencode(params)
+        url = f"{NASA_API_URL}?{query_string}"
+        
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req) as response:
+            data = json.load(response)
+        
+        results = []
+        # Socrata catalog results are in 'results'
+        items = data.get('results', [])
+        
+        for item in items:
+            ds = item.get('resource', {})
+            
+            metadata = {
+                "id": f"nasa:{ds.get('id')}", 
+                "source": "nasa",
+                "name": ds.get('name'),
+                "description": ds.get('description') or "No description available.",
+                "downloads": ds.get('download_count', 0),
+                "likes": ds.get('view_count', 0) // 10,
+                "last_updated": ds.get('updatedAt') or datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+                "quality_score": 90,
+                "license": {
+                    "id": "public_domain",
+                    "name": "Public Domain",
+                    "category": "safe",
+                    "usage_restrictions": [],
+                    "warnings": []
+                },
+                "tags": ds.get('tags', []),
+                "total_examples": 0,
+                "is_safe_source": True,
+                "is_structured": True,
+                "metadata_url": f"https://data.nasa.gov/d/{ds.get('id')}",
+                "domain": "science"
+            }
+            
+            results.append(metadata)
+                    
+        return results
+
+    except Exception as e:
+        return {"error": str(e)}
+
+def main():
+    parser = argparse.ArgumentParser(description="NASA Adapter")
+    parser.add_argument("--action", required=True, choices=["search"])
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=10)
+    
+    args = parser.parse_args()
+    
+    if args.action == "search":
+        results = search_nasa(args.query, args.limit)
+        print(json.dumps(results))
+
+if __name__ == "__main__":
+    main()

package/build/python/quality_engine.py

@@ -0,0 +1,243 @@
+import sys
+import json
+import polars as pl
+import numpy as np
+
+def analyze_column(df, col_name, dtype):
+    stats = {
+        "name": col_name,
+        "type": str(dtype),
+        "inferred_type": str(dtype), # Default to actual
+        "missing_count": 0,
+        "missing_percentage": 0.0,
+        "unique_count": 0,
+        "is_constant": False,
+        "is_mixed_type": False
+    }
+
+    try:
+        col = df[col_name]
+        null_count = col.null_count()
+        row_count = len(col)
+        
+        stats["missing_count"] = null_count
+        stats["missing_percentage"] = (null_count / row_count) * 100 if row_count > 0 else 0
+        stats["unique_count"] = col.n_unique()
+        stats["is_constant"] = stats["unique_count"] <= 1 and row_count > 0
+
+        # Schema Inference & Validation
+        is_string = dtype == pl.Utf8 or dtype == pl.Object
+        
+        if is_string and row_count > 0:
+            # Try inferring Numeric
+            # Check if majority can be cast to float
+            try:
+                # Use strict=False to turn non-numbers into nulls
+                numeric_cast = col.str.strip_chars().cast(pl.Float64, strict=False)
+                numeric_nulls = numeric_cast.null_count()
+                
+                # If valid numbers are significantly more than original nulls, it might be numeric
+                valid_numbers = row_count - numeric_nulls
+                original_valid = row_count - null_count
+                
+                if valid_numbers > 0 and (valid_numbers / original_valid) > 0.9:
+                    stats["inferred_type"] = "Numeric (Stored as String)"
+                
+                # Mixed type check: If valid numbers exist but plenty of strings too
+                elif valid_numbers > 0 and (valid_numbers / original_valid) < 0.9:
+                    stats["is_mixed_type"] = True
+            except:
+                pass
+
+        # Numeric Analysis
+        if dtype in [pl.Int64, pl.Int32, pl.Float64, pl.Float32] or stats["inferred_type"].startswith("Numeric"):
+            clean_col = col
+            if is_string:
+                 # Cast for analysis if it was inferred
+                 clean_col = col.str.strip_chars().cast(pl.Float64, strict=False)
+            
+            clean_col = clean_col.drop_nulls()
+            
+            if len(clean_col) > 0:
+                stats["distribution"] = {
+                    "min": float(clean_col.min()),
+                    "max": float(clean_col.max()),
+                    "mean": float(clean_col.mean()),
+                    "std": float(clean_col.std()) if len(clean_col) > 1 else 0,
+                    "p25": float(clean_col.quantile(0.25)),
+                    "p50": float(clean_col.median()),
+                    "p75": float(clean_col.quantile(0.75))
+                }
+
+        # Categorical Analysis
+        if dtype == pl.Utf8 or dtype == pl.Categorical:
+            value_counts = col.value_counts(sort=True).head(5)
+            # Handle different polars versions return structure for value_counts
+            try:
+                # Format: struct with name/counts or columns
+                rows = value_counts.rows()
+                top_values = {}
+                for row in rows:
+                    val = str(row[0]) if row[0] is not None else "null"
+                    count = int(row[1])
+                    top_values[val] = count
+                stats["top_values"] = top_values
+            except:
+                pass
+
+    except Exception as e:
+        stats["error"] = str(e)
+
+    return stats
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No file path provided"}))
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+    
+    try:
+        # Robust file reading with extension detection
+        file_path_lower = file_path.lower()
+        if file_path_lower.endswith(".csv"):
+            df = pl.read_csv(file_path, ignore_errors=True, n_rows=10000)
+        elif file_path_lower.endswith(".parquet"):
+            try:
+                # Try scanning first (faster for large files)
+                df = pl.scan_parquet(file_path).limit(10000).collect()
+            except:
+                df = pl.read_parquet(file_path)
+                if len(df) > 10000: df = df.head(10000)
+        elif file_path_lower.endswith(".jsonl") or file_path_lower.endswith(".ndjson"):
+            # Explicit NDJSON
+            df = pl.scan_ndjson(file_path).limit(10000).collect()
+        elif file_path_lower.endswith(".json"):
+            # Ambiguous .json: Try standard JSON first, then NDJSON fallback
+            try:
+                # read_json reads standard JSON array [{}, {}]
+                df = pl.read_json(file_path)
+                if len(df) > 10000: df = df.head(10000)
+            except Exception:
+                try:
+                     # Fallback to NDJSON (common for large datasets mislabeled as .json)
+                     df = pl.scan_ndjson(file_path).limit(10000).collect()
+                except Exception as e:
+                     print(json.dumps({"error": f"Failed to read JSON: {str(e)}"}))
+                     sys.exit(1)
+        else:
+            print(json.dumps({"error": f"Unsupported file extension: {file_path}"}))
+            sys.exit(1)
+
+        row_count = len(df)
+        column_count = len(df.columns)
+        
+        # Duplicate detection (exact)
+        try:
+            duplicate_count = df.is_duplicated().sum()
+        except Exception:
+            # Duplicate check might fail on complex nested types (List, Struct)
+            duplicate_count = 0
+        
+        columns_stats = []
+        text_cols = []
+        for col in df.columns:
+            stats = analyze_column(df, col, df.schema[col])
+            columns_stats.append(stats)
+            # Check for String type (Polars can return 'String' or 'Utf8' depending on version)
+            dtype_str = stats["type"]
+            if ("String" in dtype_str or "Utf8" in dtype_str) and stats["unique_count"] > 1:
+                text_cols.append(col)
+
+        report = {
+            "row_count": row_count,
+            "column_count": column_count,
+            "duplicate_rows": int(duplicate_count),
+            "duplicate_percentage": (duplicate_count / row_count * 100) if row_count > 0 else 0,
+            "columns": columns_stats,
+            "warnings": [],
+            "schema_warnings": [],
+            "overall_score": 100 
+        }
+
+        # Integrity Check 1: Text Duplicates (Fuzzyish Proxy)
+        # If duplicated rows are 0, check if main text content is duplicated
+        if duplicate_count == 0 and len(text_cols) > 0:
+            # Pick longest text column as likely "content"
+            # In real impl, we'd use heuristics. For now, first text col.
+            target_col = text_cols[0] 
+            text_dupes = df.select(pl.col(target_col)).is_duplicated().sum()
+            if text_dupes > 0:
+                report["text_duplicates"] = int(text_dupes)
+                if text_dupes > (row_count * 0.2):
+                    report["warnings"].append(f"High text duplication in '{target_col}' ({text_dupes} rows)")
+
+        # Integrity Check 2: Contamination / Leakage (Basic)
+        # (Skipping correlation for now)
+
+        report["class_imbalance_warnings"] = []
+        report["pii_warnings"] = []
+        
+        # PII Patterns (Regex)
+        import re
+        pii_patterns = {
+            "Email": r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+            "Phone": r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}', # Basic US-ish pattern
+            "SSN": r'\d{3}-\d{2}-\d{4}',
+            "IPv4": r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
+        }
+
+        # Bias & PII Analysis
+        for col_name, stats in zip(df.columns, columns_stats):
+            # Class Imbalance
+            if stats["unique_count"] > 1 and stats["unique_count"] < 50:
+                 try:
+                     col = df[col_name]
+                     top_val_count = col.value_counts().sort("count", descending=True).row(0)[1]
+                     total = len(col)
+                     if total > 0:
+                         ratio = top_val_count / total
+                         if ratio > 0.9:
+                             report["class_imbalance_warnings"].append(f"Severe imbalance in '{col_name}': Top class is {(ratio*100):.1f}% of data")
+                 except:
+                     pass
+            
+            # PII Detection (on Text Columns only)
+            if ("String" in stats["type"] or "Utf8" in stats["type"]):
+                try:
+                    # Sample for performance (check first 1000 non-null values)
+                    sample_text = df[col_name].drop_nulls().head(1000).to_list()
+                    # Join a subset to regex against (faster than row-by-row for simple checks)
+                    combined_text = " ".join([str(x) for x in sample_text])
+                    
+                    for pii_type, pattern in pii_patterns.items():
+                        if re.search(pattern, combined_text):
+                            # Ensure we don't flag column names like "email_address" but actual content
+                            # Double check with a strict count if trigger found
+                            matches = len(re.findall(pattern, combined_text))
+                            if matches > 0:
+                                report["pii_warnings"].append(f"Potential {pii_type} detected in column '{col_name}' ({matches} matches in sample)")
+                except:
+                    pass
+
+        # Basic warnings
+        if report["duplicate_percentage"] > 10:
+            report["warnings"].append("High duplication rate (>10%)")
+        if row_count < 50:
+            report["warnings"].append("Dataset is very small (<50 rows)")
+
+        # Schema warnings
+        for col in columns_stats:
+            if "Numeric" in col.get("inferred_type", "") and "Utf8" in col.get("type", ""):
+                 report["schema_warnings"].append(f"Column '{col['name']}' looks Numeric but is stored as String")
+            if col.get("is_mixed_type"):
+                 report["schema_warnings"].append(f"Column '{col['name']}' likely contains mixed types (numbers and strings)")
+
+        print(json.dumps(report))
+
+    except Exception as e:
+        print(json.dumps({"error": f"Analysis failed: {str(e)}"}))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()