@vespermcp/mcp-server 1.0.0

package/src/python/framework_adapters.py

@@ -0,0 +1,100 @@
+import os
+import json
+import warnings
+
+# --- PyTorch Adapter ---
+try:
+    import torch
+    from torch.utils.data import Dataset
+    import polars as pl
+    
+    class VesperPyTorchDataset(Dataset):
+        """
+        PyTorch Dataset wrapper for Vesper exported files (Parquet/CSV/Arrow).
+        Efficiently loads data using Polars and converts to Tensors on demand.
+        """
+        def __init__(self, file_path, target_col=None, transform=None):
+            self.file_path = file_path
+            self.target_col = target_col
+            self.transform = transform
+            
+            # Auto-detect format
+            if file_path.endswith(".parquet"):
+                self.df = pl.read_parquet(file_path)
+            elif file_path.endswith(".csv"):
+                self.df = pl.read_csv(file_path, ignore_errors=True)
+            elif file_path.endswith(".arrow"):
+                self.df = pl.read_ipc(file_path)
+            else:
+                raise ValueError(f"Unsupported file format for PyTorch loader: {file_path}")
+                
+            self.data = self.df.to_pandas() # Convert to pandas for easier row access in __getitem__ (Polars slice can be slow row-wise)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, idx):
+            row = self.data.iloc[idx]
+            
+            # Simple assumption: all numeric columns except target are features
+            # In production, metadata would tell us which columns are features
+            if self.target_col and self.target_col in row:
+                y = row[self.target_col]
+                x = row.drop(self.target_col).values
+                
+                # Convert to tensors
+                x = torch.tensor(x, dtype=torch.float32)
+                # Auto-detect target type (scalar vs class index)
+                if isinstance(y, (int, float)):
+                     y = torch.tensor(y, dtype=torch.float32) # Regression/Binary
+                else:
+                    # TODO: Label encoding if string
+                    pass
+                
+                sample = (x, y)
+            else:
+                # Unsupervised
+                x = torch.tensor(row.values, dtype=torch.float32)
+                sample = x
+
+            if self.transform:
+                sample = self.transform(sample)
+
+            return sample
+
+except ImportError:
+    class VesperPyTorchDataset:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("PyTorch or Polars not installed.")
+
+# --- HuggingFace Adapter ---
+try:
+    from datasets import load_dataset as hf_load_dataset
+    
+    def load_vesper_dataset(file_path):
+        """
+        Loads a Vesper export into a Hugging Face Dataset.
+        Supported: Parquet, CSV, JSONL, Arrow.
+        """
+        output_format = "parquet" # Default fallback
+        if file_path.endswith(".csv"): output_format = "csv"
+        elif file_path.endswith(".jsonl"): output_format = "json"
+        elif file_path.endswith(".arrow"): output_format = "arrow"
+        
+        # 'arrow' format in HF might need custom script, but usually parquet/csv/json are native
+        if output_format == "arrow":
+             # Use pandas/polars to read then convert to HF dataset
+             import polars as pl
+             from datasets import Dataset
+             df = pl.read_ipc(file_path).to_pandas()
+             return Dataset.from_pandas(df)
+        
+        return hf_load_dataset(output_format, data_files=file_path, split="train")
+
+except ImportError:
+    def load_vesper_dataset(*args, **kwargs):
+        raise ImportError("HuggingFace 'datasets' library not installed.")
+
+if __name__ == "__main__":
+    print("Vesper Framework Adapters Library")
+    print("Usage: import this module in your training script.")

package/src/python/github_adapter.py

@@ -0,0 +1,106 @@
+import sys
+import json
+import argparse
+import urllib.request
+import urllib.parse
+import os
+from datetime import datetime
+
+GITHUB_API_URL = "https://api.github.com/search/repositories"
+
+def search_github(query: str, limit: int = 10):
+    """
+    Search GitHub for dataset repositories.
+    """
+    try:
+        # Construct refined query:
+        # User query + (topic:dataset OR topic:data)
+        # We also filter for repositories with > 5 stars to ensure some relevance
+        refined_query = f"{query} topic:dataset stars:>5"
+        
+        params = {
+            "q": refined_query,
+            "sort": "stars",
+            "order": "desc",
+            "per_page": limit
+        }
+        
+        query_string = urllib.parse.urlencode(params)
+        url = f"{GITHUB_API_URL}?{query_string}"
+        
+        req = urllib.request.Request(url)
+        
+        # Add User-Agent (Required by GitHub)
+        req.add_header("User-Agent", "Vesper-Dataset-Search")
+        
+        # Add Authorization if token exists
+        token = os.environ.get("GITHUB_TOKEN")
+        if token:
+            req.add_header("Authorization", f"token {token}")
+        
+        with urllib.request.urlopen(req) as response:
+            data = json.load(response)
+        
+        items = data.get('items', [])
+        results = []
+        
+        for item in items:
+            # Map GitHub fields to Vesper schema
+            # repo: owner/name
+            repo_id = item.get("full_name")
+            
+            # Simple licensing map
+            license_info = item.get("license") or {}
+            license_key = license_info.get("key", "unknown")
+            license_category = "safe" if license_key in ["mit", "apache-2.0", "cc0-1.0", "bsd-3-clause"] else "unknown"
+            
+            metadata = {
+                "id": f"github:{repo_id}", 
+                "source": "github",
+                "name": item.get("name"),
+                "description": item.get("description") or "No description provided.",
+                "downloads": item.get("forks_count") * 10, # Proxy estimation
+                "likes": item.get("stargazers_count"),
+                "stars": item.get("stargazers_count"),
+                "last_updated": item.get("updated_at"),
+                "quality_score": min(100, 50 + (item.get("stargazers_count", 0))), # Rough heuristic
+                "license": {
+                    "id": license_key,
+                    "name": license_info.get("name", "Unknown"),
+                    "category": license_category,
+                    "usage_restrictions": [],
+                    "warnings": []
+                },
+                "tags": item.get("topics", []),
+                "total_examples": 0, # Unknown without drilling deeper
+                "is_safe_source": True, # GitHub is generally safe code, content varies
+                "is_structured": False, # Often contains code + data
+                "metadata_url": item.get("html_url"),
+                "domain": "general"
+            }
+            
+            results.append(metadata)
+            
+        return results
+
+    except urllib.error.HTTPError as e:
+        if e.code == 403:
+            return {"error": "Rate limit exceeded. Set GITHUB_TOKEN environment variable."}
+        return {"error": f"HTTP Error {e.code}: {e.reason}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+def main():
+    parser = argparse.ArgumentParser(description="GitHub 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_github(args.query, args.limit)
+        print(json.dumps(results))
+
+if __name__ == "__main__":
+    main()

package/src/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/src/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/src/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()