Duplicate from evalstate/mcp-clients

Co-authored-by: shaun smith <evalstate@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Hugging Face
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,123 @@
+---
+configs:
+- config_name: deduplicated
+  data_files:
+  - split: deduplicated
+    path: deduplicated/deduplicated-*
+- config_name: raw
+  data_files:
+  - split: raw
+    path: raw/raw-*
+license: mit
+tags:
+- code
+- agent
+size_categories:
+- 1K<n<10K
+dataset_info:
+- config_name: deduplicated
+  features:
+  - name: name
+    dtype: string
+  - name: versions
+    dtype: string
+  - name: capabilities
+    dtype: string
+  - name: last_seen
+    dtype: string
+  splits:
+  - name: deduplicated
+    num_bytes: 49101
+    num_examples: 486
+  download_size: 21632
+  dataset_size: 49101
+- config_name: raw
+  features:
+  - name: name
+    dtype: string
+  - name: version
+    dtype: string
+  - name: capabilities
+    dtype: string
+  - name: last_seen
+    dtype: string
+  splits:
+  - name: raw
+    num_bytes: 135102
+    num_examples: 1586
+  download_size: 40277
+  dataset_size: 135102
+---
+
+# MCP Clients Dataset
+
+This data contains MCP Client identity and capability information logged by the MCP Server at `huggingface.co/mcp`. 
+
+The data is updated daily (~4AM UTC), and represents the last ~7m sessions. 
+
+## Dataset Contents
+
+The dataset contains two configurations, `raw` and `deduplicated`. 
+
+Raw contains distinct (name,version,capabilities) and a timestamp of the latest that distinct configuration was seen.
+
+Deduplicated removes `mcp-remote` suffixes, groups by distinct (name,capabilities),  concatenates the version numbers found and retains the last_seen timestamp. Note that further post-processing may be added to handle specific clients such as `postman`.
+
+### Raw Split (`raw`)
+- **name**: MCP client name (e.g., "Cursor", "Anthropic/ClaudeAI", "chat-ui-mcp")
+- **version**: Client version
+- **capabilities**: Client capabilities (JSON string)
+- **last_seen**: Most recent timestamp when this distinct client configuration was seen
+
+### Deduplicated Split (`deduplicated`)
+- **name**: MCP client name (normalized, mcp-remote suffix stripped)
+- **versions**: All versions seen for this client (comma-separated)
+- **capabilities**: Client capabilities (JSON string)
+- **last_seen**: Most recent timestamp when this distinct client configuration was seen
+
+## Notes about the Data
+
+- Some Clients only send capabilities that have been configured (for example, `fast-agent` only sends the `roots` capability if roots are configured)
+- There are a number of capabilities out of specification that are helpful to track (e.g. MCP-UI, Skybridge, Apps SDK). We encourage the use of `experimental` to advertise these capabilities for tracking.
+- The `deduplicated` split groups clients by (name, capabilities), concatenating all versions together.
+- The Protocol Version not currently captured - future datasets may include this
+
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+# Load raw clients
+raw_ds = load_dataset('evalstate/mcp-clients', 'raw')
+for client in raw_ds['raw']:
+    print(f"{client['name']} v{client['version']}")
+
+# Load deduplicated clients
+dedup_ds = load_dataset('evalstate/mcp-clients', 'deduplicated')
+for client in dedup_ds['deduplicated']:
+    print(f"{client['name']}: {client['versions']}")
+```
+
+## Updating the Dataset
+
+The dataset is kept up-to-date via Hugging Face Jobs:
+
+1. **Extract step** (`raw` split):
+   ```bash
+   uv run https://huggingface.co/datasets/evalstate/mcp-clients/resolve/main/extract_mcp_clients.py --push-to-hub --split raw
+   ```
+
+2. **Deduplicate step** (`deduplicated` split):
+   ```bash
+   uv run https://huggingface.co/datasets/evalstate/mcp-clients/resolve/main/deduplicate_clients.py --push-to-hub
+   ```
+
+Or run the full pipeline:
+   ```bash
+   uv run https://huggingface.co/datasets/evalstate/mcp-clients/resolve/main/pipeline.py
+   ```
+
+## License
+
+MIT

data/deduplicated-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0022e0aa74f26cdad480557f76e8e3aa8beb9ff6ae925db1d3a2df638b713850
+size 19027

data/raw-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f4c75203c4976394ccdeada2697d660957abe801871a5e331fe39b0716a5247
+size 35096

deduplicate_clients.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env -S uv run
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "huggingface_hub",
+# ]
+# ///
+
+"""
+Deduplicate MCP clients by name and capabilities.
+
+This script takes the existing mcp-clients dataset and creates a deduplicated view
+where rows are unique by (name, capabilities). When multiple versions exist for
+the same (name, capabilities), they are concatenated with "," in a versions column.
+
+It also strips " (via mcp-remote X.Y.Z)" suffixes from client names and reports
+the mcp-remote versions encountered.
+
+Usage:
+    # Push deduplicated data to the same repo (evalstate/mcp-clients) under 'deduplicated' split
+    uv run deduplicate_clients.py --push-to-hub
+
+    # Read from raw, push to dedup split in same repo
+    uv run deduplicate_clients.py --source-split raw --target-split deduplicated --push-to-hub
+
+    # Output to local file
+    uv run deduplicate_clients.py -o deduplicated.ndjson
+"""
+
+import sys
+import json
+import re
+import argparse
+from datetime import datetime
+from collections import defaultdict
+
+from datasets import Dataset, Features, Value, load_dataset
+
+
+# Regex to match "(via mcp-remote X.Y.Z)" suffix
+MCP_REMOTE_PATTERN = re.compile(r'\s*\(via mcp-remote [\d.]+\)')
+
+
+def strip_mcp_remote_suffix(name):
+    """Remove the '(via mcp-remote X.Y.Z)' suffix from client name."""
+    match = MCP_REMOTE_PATTERN.search(name)
+    if match:
+        # Extract the version number from the suffix
+        suffix = match.group(0)
+        version_match = re.search(r'mcp-remote ([\d.]+)', suffix)
+        if version_match:
+            version = version_match.group(1)
+            return MCP_REMOTE_PATTERN.sub('', name).strip(), version
+    return name, None
+
+
+def normalize_capabilities(caps):
+    """Normalize capabilities for comparison."""
+    if caps is None:
+        return None
+    if isinstance(caps, str):
+        if caps == '{}':
+            return {}
+        try:
+            return json.loads(caps)
+        except Exception:
+            return caps
+    return caps
+
+
+def capabilities_to_string(caps):
+    """Convert capabilities to JSON string for storage."""
+    if caps is None:
+        return ''
+    if isinstance(caps, dict):
+        return json.dumps(caps, sort_keys=True)
+    return str(caps)
+
+
+def create_dataset_from_deduplicated(deduplicated_list, features=None):
+    """Create a Hugging Face Dataset from the deduplicated list."""
+    if features is None:
+        # Use 'versions' (plural) for the deduplicated split
+        features = Features({
+            'name': Value('string'),
+            'versions': Value('string'),
+            'capabilities': Value('string'),
+            'last_seen': Value('string'),
+        })
+
+    records = []
+    for client in deduplicated_list:
+        records.append({
+            'name': client['name'],
+            'versions': client['versions'],
+            'capabilities': capabilities_to_string(client['capabilities']),
+            'last_seen': client['last_seen'],
+        })
+
+    return Dataset.from_list(records, features=features)
+
+
+def push_to_hub(deduplicated_list, repo_id, split=None, token=None, private=False):
+    """Push the deduplicated dataset to Hugging Face Hub."""
+    dataset = create_dataset_from_deduplicated(deduplicated_list)
+
+    if split:
+        print(f"Pushing dataset to https://huggingface.co/datasets/{repo_id} (config: deduplicated, split: {split})", file=sys.stderr)
+    else:
+        print(f"Pushing dataset to https://huggingface.co/datasets/{repo_id} (config: deduplicated)", file=sys.stderr)
+
+    # Push to hub with explicit config_name to avoid creating "default" config
+    # This ensures the data goes to the "deduplicated" config, not a "default" config
+    dataset.push_to_hub(
+        repo_id=repo_id,
+        config_name="deduplicated",  # Explicitly set config name to avoid "default" config creation
+        split=split,
+        token=token,
+        private=private,
+        commit_message=f"Update deduplicated clients ({datetime.now().strftime('%Y-%m-%d %H:%M')})",
+    )
+
+    print(f"Successfully pushed {len(deduplicated_list):,} deduplicated records to {repo_id}", file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Deduplicate MCP clients by name and capabilities",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Push deduplicated data to same repo under 'deduplicated' split
+  %(prog)s --push-to-hub
+
+  # Use custom source/target splits
+  %(prog)s --source-split raw --target-split dedup --push-to-hub
+
+  # Output to local file
+  %(prog)s -o deduplicated.ndjson
+
+  # Push to a different repo
+  %(prog)s --target-repo my-org/mcp-clients-dedup --push-to-hub
+        """
+    )
+    parser.add_argument("-o", "--output", help="Output file path (default: stdout)")
+    parser.add_argument("--source-repo", default="evalstate/mcp-clients",
+                        help="Source repository ID (default: evalstate/mcp-clients)")
+    parser.add_argument("--source-config", default="raw",
+                        help="Source config name (default: raw)")
+    parser.add_argument("--source-split", default=None,
+                        help="Source split name (optional, defaults to config name)")
+    parser.add_argument("--target-repo", default="evalstate/mcp-clients",
+                        help="Target repository ID (default: evalstate/mcp-clients)")
+    parser.add_argument("--target-split", default="deduplicated",
+                        help="Target split name (default: deduplicated)")
+    parser.add_argument("--push-to-hub", action="store_true",
+                        help="Push the resulting dataset to Hugging Face Hub")
+    parser.add_argument("--token", default=None,
+                        help="HF token (defaults to HF_TOKEN env var or cached token)")
+    parser.add_argument("--private", action="store_true",
+                        help="Create/push to a private repository")
+    args = parser.parse_args()
+
+    # Use config name as split if not specified
+    source_split = args.source_split or args.source_config
+
+    print(f"[{datetime.now().isoformat()}] Loading dataset from {args.source_repo} (config: {args.source_config}, split: {source_split})...", file=sys.stderr)
+
+    # Load the source dataset using config name (required for multi-config datasets)
+    ds = load_dataset(args.source_repo, args.source_config, split=source_split)
+
+    print(f"[{datetime.now().isoformat()}] Loaded {len(ds):,} client records", file=sys.stderr)
+
+    # Track mcp-remote versions found
+    mcp_remote_versions = defaultdict(int)
+
+    # Group by (name, capabilities)
+    groups = defaultdict(list)
+
+    for row in ds:
+        # Strip mcp-remote suffix from name
+        clean_name, mcp_version = strip_mcp_remote_suffix(row['name'])
+
+        if mcp_version:
+            mcp_remote_versions[mcp_version] += 1
+
+        # Normalize capabilities for grouping
+        caps = normalize_capabilities(row['capabilities'])
+        caps_key = capabilities_to_string(caps)
+
+        key = (clean_name, caps_key)
+        groups[key].append({
+            'name': clean_name,
+            'version': row['version'],
+            'capabilities': caps,
+            'last_seen': row['last_seen'],
+        })
+
+    print(f"[{datetime.now().isoformat()}] Found {len(groups):,} unique (name, capabilities) combinations", file=sys.stderr)
+
+    # Print mcp-remote version summary
+    if mcp_remote_versions:
+        total_with_mcp_remote = sum(mcp_remote_versions.values())
+        print(f"[{datetime.now().isoformat()}] MCP-remote version summary:", file=sys.stderr)
+        print(f"  Total records with mcp-remote suffix: {total_with_mcp_remote:,}", file=sys.stderr)
+        print(f"  Unique mcp-remote versions: {len(mcp_remote_versions)}", file=sys.stderr)
+        print(f"  Versions encountered:", file=sys.stderr)
+        for version in sorted(mcp_remote_versions.keys()):
+            print(f"    - mcp-remote {version}: {mcp_remote_versions[version]:,} records", file=sys.stderr)
+        print()
+
+    # Create deduplicated records
+    deduplicated = []
+
+    for (name, caps_key), records in groups.items():
+        # Find the latest last_seen
+        latest_record = max(records, key=lambda x: x['last_seen'])
+
+        # Collect all unique versions (sorted)
+        versions = sorted(set(r['version'] for r in records))
+        versions_str = ','.join(versions)
+
+        deduplicated.append({
+            'name': name,
+            'versions': versions_str,
+            'capabilities': latest_record['capabilities'],
+            'last_seen': latest_record['last_seen'],
+        })
+
+    # Sort by last_seen descending (so latest are at the beginning)
+    deduplicated.sort(key=lambda x: x['last_seen'], reverse=True)
+
+    print(f"[{datetime.now().isoformat()}] Created {len(deduplicated):,} deduplicated records", file=sys.stderr)
+
+    # Handle push to hub
+    if args.push_to_hub:
+        push_to_hub(deduplicated, args.target_repo, split=args.target_split, token=args.token, private=args.private)
+        return
+
+    # Handle local output
+    if args.output:
+        out_file = open(args.output, 'w')
+    else:
+        out_file = sys.stdout
+
+    # Output as NDJSON
+    for client in deduplicated:
+        out_file.write(json.dumps(client) + '\n')
+
+    if args.output:
+        out_file.close()
+        print(f"Output written to: {args.output}", file=sys.stderr)
+
+
+if __name__ == '__main__':
+    main()

deduplicated/deduplicated-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:282bd453cc15756598a88d941192cfe38ef784d3ff105568193c26d4c5f39f48
+size 21632

extract_mcp_clients.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env -S uv run
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "huggingface_hub",
+# ]
+# ///
+"""
+Extract unique MCP client combinations (name, version, capabilities) from evalstate/hf-mcp-logs dataset.
+Only processes "initialize" method calls - ignores "session_delete" events which lack complete client information.
+Tracks most recent "last seen" timestamp for each unique client configuration.
+Uses batched streaming for efficient I/O on large datasets (~7M rows).
+
+Usage:
+    # Process all data and save to local file
+    python3.10 extract_mcp_clients.py -o clients.ndjson
+
+    # Push to Hugging Face Hub (creates/updates evalstate/mcp-clients dataset)
+    python3.10 extract_mcp_clients.py --push-to-hub
+
+    # Push to a specific split (for scheduled pipelines)
+    python3.10 extract_mcp_clients.py --push-to-hub --split raw
+
+    # Process a sample for testing
+    python3.10 extract_mcp_clients.py --limit 10000 -o sample.ndjson
+
+Output fields:
+    - name: MCP client name (e.g., "Cursor", "Anthropic/ClaudeAI", "chat-ui-mcp")
+    - version: Client version
+    - capabilities: Client capabilities (JSON object or null)
+    - last_seen: Most recent timestamp when this client was seen
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from datasets import Dataset, Features, Value
+from huggingface_hub import HfApi
+
+
+def normalize_capabilities(caps):
+    """Normalize capabilities for comparison."""
+    if caps is None:
+        return None
+    if isinstance(caps, str):
+        # Parse stringified JSON if needed
+        if caps == '{}':
+            return {}
+        try:
+            return json.loads(caps)
+        except Exception:
+            return caps
+    return caps
+
+
+def capabilities_to_string(caps):
+    """Convert capabilities to JSON string for storage."""
+    if caps is None:
+        return ''
+    if isinstance(caps, dict):
+        return json.dumps(caps, sort_keys=True)
+    return str(caps)
+
+
+def create_dataset_from_clients(clients_list, features=None):
+    """Create a Hugging Face Dataset from the clients list."""
+    if features is None:
+        features = Features({
+            'name': Value('string'),
+            'version': Value('string'),
+            'capabilities': Value('string'),  # Store as JSON string for consistency
+            'last_seen': Value('string'),
+        })
+
+    # Convert to records format for Dataset
+    records = []
+    for client in clients_list:
+        record = {
+            'name': client['name'],
+            'version': client['version'],
+            'capabilities': capabilities_to_string(client['capabilities']),
+            'last_seen': client['last_seen'],
+        }
+        records.append(record)
+
+    return Dataset.from_list(records, features=features)
+
+
+def push_to_hub(clients_list, repo_id, split=None, token=None, private=False):
+    """Push the clients dataset to Hugging Face Hub."""
+    # Create dataset from clients
+    dataset = create_dataset_from_clients(clients_list)
+
+    # Determine split for push
+    if split:
+        print(f"Pushing dataset to https://huggingface.co/datasets/{repo_id} (config: raw, split: {split})", file=sys.stderr)
+    else:
+        print(f"Pushing dataset to https://huggingface.co/datasets/{repo_id} (config: raw)", file=sys.stderr)
+
+    # Push to hub with explicit config_name to avoid creating "default" config
+    # This ensures the data goes to the "raw" config, not a "default" config
+    dataset.push_to_hub(
+        repo_id=repo_id,
+        config_name="raw",  # Explicitly set config name to avoid "default" config creation
+        split=split,
+        token=token,
+        private=private,
+        commit_message=f"Update MCP clients dataset ({datetime.now().strftime('%Y-%m-%d %H:%M')})",
+    )
+    print(f"Successfully pushed {len(clients_list):,} clients to {repo_id}", file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Extract unique MCP clients with last seen timestamp from evalstate/hf-mcp-logs",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Process all data and save to local file
+  %(prog)s -o clients.ndjson
+
+  # Push to Hugging Face Hub (requires authentication: `hf auth login`)
+  %(prog)s --push-to-hub
+
+  # Push to a specific split (ideal for scheduled jobs/pipelines)
+  %(prog)s --push-to-hub --split raw
+
+  # Process with limit (for testing)
+  %(prog)s --limit 10000 -o sample.ndjson
+
+  # Push to a private repo
+  %(prog)s --push-to-hub --private
+        """
+    )
+    parser.add_argument("-o", "--output", help="Output file path (default: stdout)")
+    parser.add_argument("--limit", type=int,
+                        help="Limit processing to N rows (useful for testing)")
+    parser.add_argument("--format", choices=["ndjson", "csv"], default="ndjson",
+                        help="Output format (default: ndjson)")
+    parser.add_argument("--batch-size", type=int, default=1000,
+                        help="Batch size for streaming (default: 1000). Larger values may "
+                             "improve I/O efficiency but use more memory.")
+    parser.add_argument("--push-to-hub", action="store_true",
+                        help="Push the resulting dataset to Hugging Face Hub")
+    parser.add_argument("--split", default=None,
+                        help="Split name when pushing to Hub (e.g., 'raw' for scheduled pipelines)")
+    parser.add_argument("--repo-id", default="evalstate/mcp-clients",
+                        help="HF Hub repository ID (default: evalstate/mcp-clients)")
+    parser.add_argument("--token", default=None,
+                        help="HF token (defaults to HF_TOKEN env var or cached token)")
+    parser.add_argument("--private", action="store_true",
+                        help="Create/push to a private repository")
+    args = parser.parse_args()
+
+    # Dictionary to track unique (name, version, capabilities) -> data
+    unique_clients = {}
+
+    # Load dataset in streaming mode with batch processing
+    print(f"Loading dataset: evalstate/hf-mcp-logs (sessions split)", file=sys.stderr)
+    print(f"Using batch size: {args.batch_size}", file=sys.stderr)
+
+    from datasets import load_dataset
+    ds = load_dataset('evalstate/hf-mcp-logs', 'sessions', streaming=True)
+    # Access sessions split
+    sessions_ds = ds['sessions']
+
+    total_rows = 0
+    skipped_deletes = 0
+    skipped_other = 0
+    start_time = None
+
+    # Process in batches for better I/O efficiency
+    for batch in sessions_ds.iter(batch_size=args.batch_size):
+        batch_len = len(batch['name'])  # All columns have same length
+        total_rows += batch_len
+
+        # Progress indicator every 100k rows
+        if total_rows % 100000 == 0:
+            if start_time is None:
+                start_time = datetime.now()
+            elapsed = (datetime.now() - start_time).total_seconds()
+            rate = total_rows / elapsed if elapsed > 0 else 0
+            print(f"Processed {total_rows:,} rows ({rate:.0f} rows/sec), "
+                  f"found {len(unique_clients):,} unique clients, "
+                  f"skipped {skipped_deletes:,} delete events...", file=sys.stderr)
+
+        if args.limit and total_rows > args.limit:
+            break
+
+        # Process each row in batch
+        # Batch is a dict where keys are column names and values are lists
+        for i in range(batch_len):
+            # Check methodName field - only process 'initialize' events
+            method_name = batch['methodName'][i] if 'methodName' in batch else None
+            
+            # Skip session_delete events - they don't have meaningful client information
+            if method_name == 'session_delete':
+                skipped_deletes += 1
+                continue
+            
+            # Only process initialize events
+            if method_name != 'initialize':
+                skipped_other += 1
+                continue
+            
+            name = batch['name'][i]
+            version = batch['version'][i]
+            capabilities = normalize_capabilities(batch['capabilities'][i])
+            time_str = batch['time'][i]
+
+            if not all([name, version, time_str]):
+                continue
+
+            # Create composite key for deduplication
+            # For capabilities, we need a hashable representation
+            if isinstance(capabilities, dict):
+                cap_key = json.dumps(capabilities, sort_keys=True)
+            else:
+                cap_key = str(capabilities) if capabilities is not None else None
+
+            key = (name, version, cap_key)
+
+            # Update if this entry is newer
+            if key not in unique_clients or time_str > unique_clients[key]['last_seen']:
+                unique_clients[key] = {
+                    'name': name,
+                    'version': version,
+                    'capabilities': capabilities,
+                    'last_seen': time_str
+                }
+
+    print(f"\nProcessing complete: {total_rows:,} rows processed", file=sys.stderr)
+    print(f"Skipped {skipped_deletes:,} session_delete events", file=sys.stderr)
+    if skipped_other > 0:
+        print(f"Skipped {skipped_other:,} other non-initialize events", file=sys.stderr)
+    print(f"Found {len(unique_clients):,} unique client configurations", file=sys.stderr)
+
+    # Sort by last_seen descending (most recent first)
+    sorted_clients = sorted(
+        unique_clients.values(),
+        key=lambda x: x['last_seen'],
+        reverse=True
+    )
+
+    # Handle push to hub
+    if args.push_to_hub:
+        push_to_hub(sorted_clients, args.repo_id, split=args.split, token=args.token, private=args.private)
+        return
+
+    # Handle local output
+    if args.output:
+        out_file = open(args.output, 'w')
+    else:
+        out_file = sys.stdout
+
+    # Output results
+    if args.format == 'ndjson':
+        for client in sorted_clients:
+            # Ensure capabilities is output properly
+            if client['capabilities'] == '{}':
+                client['capabilities'] = {}
+
+            out_file.write(json.dumps(client) + '\n')
+
+    elif args.format == 'csv':
+        # Write CSV header
+        import csv
+        writer = csv.writer(out_file)
+        writer.writerow(['name', 'version', 'capabilities', 'last_seen'])
+
+        for client in sorted_clients:
+            # Convert capabilities to string for CSV
+            caps = client['capabilities']
+            if isinstance(caps, dict):
+                caps_str = json.dumps(caps)
+            elif caps is None:
+                caps_str = ''
+            else:
+                caps_str = str(caps)
+
+            writer.writerow([client['name'], client['version'], caps_str, client['last_seen']])
+
+    if args.output:
+        out_file.close()
+        print(f"Output written to: {args.output}", file=sys.stderr)
+
+
+if __name__ == '__main__':
+    main()

pipeline.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env -S uv run
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "datasets",
+#     "huggingface_hub",
+# ]
+# ///
+"""
+MCP Clients Pipeline
+
+Runs the full extract → deduplicate pipeline for the MCP clients dataset.
+
+Usage:
+    uv run https://huggingface.co/datasets/evalstate/mcp-clients/resolve/main/pipeline.py
+
+The pipeline:
+    1. Extracts unique clients from evalstate/hf-mcp-logs
+    2. Pushes to evalstate/mcp-clients (raw split)
+    3. Creates deduplicated view
+    4. Pushes to evalstate/mcp-clients (deduplicated split)
+"""
+
+import subprocess
+import sys
+from datetime import datetime
+
+
+def run_script(url: str, args: list[str]) -> bool:
+    """Run a script via uv run and return success status."""
+    cmd = ["uv", "run", url] + args
+    print(f"[{datetime.now().isoformat()}] Running: {' '.join(cmd)}", file=sys.stderr)
+    
+    result = subprocess.run(cmd, capture_output=False)
+    
+    if result.returncode == 0:
+        print(f"[{datetime.now().isoformat()}] Success", file=sys.stderr)
+        return True
+    else:
+        print(f"[{datetime.now().isoformat()}] Failed with exit code {result.returncode}", file=sys.stderr)
+        return False
+
+
+def main():
+    base_url = "https://huggingface.co/datasets/evalstate/mcp-clients/resolve/main"
+    
+    print(f"[{datetime.now().isoformat()}] Starting MCP clients pipeline...", file=sys.stderr)
+    
+    # Step 1: Extract to raw split
+    print(f"[{datetime.now().isoformat()}] Step 1: Extracting clients from hf-mcp-logs...", file=sys.stderr)
+    success = run_script(
+        f"{base_url}/extract_mcp_clients.py",
+        ["--push-to-hub", "--split", "raw"]
+    )
+    
+    if not success:
+        print(f"[{datetime.now().isoformat()}] Pipeline failed at extract step", file=sys.stderr)
+        sys.exit(1)
+    
+    # Step 2: Deduplicate to deduplicated split
+    print(f"[{datetime.now().isoformat()}] Step 2: Creating deduplicated view...", file=sys.stderr)
+    success = run_script(
+        f"{base_url}/deduplicate_clients.py",
+        ["--push-to-hub"]
+    )
+    
+    if not success:
+        print(f"[{datetime.now().isoformat()}] Pipeline failed at dedup step", file=sys.stderr)
+        sys.exit(1)
+    
+    print(f"[{datetime.now().isoformat()}] Pipeline complete!", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

raw/raw-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7d191f645d38f4a76153b696e0108a192868fe661708d5a05a4bade366cb127
+size 40277