semvec/pypi-packages huggingface dataset:
iflow-mcp_snowflake-labs-cortex-agents-mcp 0.1.2
MCP server for Snowflake Cortex Agents - allows agents to interact with Cortex Agents as a tool
Requires Python: >=3.11

# Build an MCP Server for Cortex Agents

## Overview

This guide walks through how to build your own MCP Server for Cortex Agents.

The core functionalities include:

- Allow agents to interact with Cortex Agents as a tool
- Test the connection with Claude Desktop

In this tutorial, we’ll build a simple MCP **Cortex Agent** server and connect it to an MCP host (Claude for Desktop).

## Step-by-Step Guide

For prerequisites, environment setup, step-by-step guide and instructions, please refer to the [QuickStart Guide](https://quickstarts.snowflake.com/guide/mcp-server-for-cortex-agents/index.html).
kluster-fudge 0.3.0
A Python library for clustering categorical data using K-Modes with various distance metrics.
Requires Python: >=3.7

# KlusterFudge

A Python library for clustering categorical data using the **K-Modes** algorithm. It supports multiple initialization methods and distance metrics, optimized with `numba` for performance.

[Documentation](https://ethqnol.github.io/KlusterFudge/) | [PyPI](https://pypi.org/project/kluster-fudge/)

## Features
- **Algorithms**: K-Modes clustering for categorical data
- **GPU Acceleration**: Optional PyTorch-based GPU acceleration via `KModesGPU`
- **Distance Metrics**: Hamming, Jaccard, and NG dissimilarity measures
- **Initialization**: Random, Huang, and Cao methods
- **Optimization**: CPU operations accelerated with `numba`, GPU operations with PyTorch
- **Integration**: Supports all ArrayLikes (numpy arrays, pandas DataFrames, lists, etc.)

## Installation

Install `KlusterFudge` via pip:

```bash
pip install kluster-fudge
```

Or install from source:

```bash
git clone https://github.com/ethqnol/KlusterFudge.git
cd KlusterFudge
pip install .
```

### GPU Acceleration (Optional)

For GPU acceleration, install PyTorch:

```bash
pip install torch
```

See [PyTorch installation guide](https://pytorch.org/get-started/locally/) for CUDA/ROCm support.


## Quick Start

```python
import pandas as pd
from kluster_fudge import KModes

# 1. Load Data
df = pd.DataFrame({
    'color': ['red', 'blue', 'red', 'green', 'blue', 'green'],
    'size': ['small', 'large', 'small', 'large', 'medium', 'medium'],
    'shape': ['circle', 'square', 'circle', 'square', 'triangle', 'triangle']
})

# 2. Initialize Model
model = KModes(
    n_clusters=2, 
    init_method='cao', 
    dist_metric='hamming', 
    random_state=42
)

# 3. Fit and Predict
clusters = model.fit_predict(df)
print("Cluster Labels:", clusters)
```

## GPU Acceleration

For large datasets, use `KModesGPU` for significant speedups (unless using NG dissimilarity):

```python
from kluster_fudge import KModesGPU
import numpy as np

# Large dataset
X = np.random.randint(0, 10, size=(100000, 20))

# GPU model (auto-detects CUDA/MPS/CPU)
model_gpu = KModesGPU(n_clusters=5, n_init=5, random_state=42)
model_gpu.fit(X)

# 3-6x faster than CPU on typical datasets
```

**Performance**: On a 100k sample dataset, GPU achieves ~3.2x speedup on Apple Silicon (MPS) and up to 6x on CUDA GPUs.

## Comparisons & Benchmarks

See `benchmarks/benchmark_metrics.py` 

| Metric    | Init  | Time (s) |
|---------|---------|----------|
| jaccard | cao | 0.051574 |
| jaccard | huang | 0.051677 |
| hamming | cao | 0.052091 |
| hamming | huang | 0.052477 |
| ng | huang | 0.055497 |
| ng | cao | 0.055761 |
| jaccard | random | 0.569103 |
| ng | random | 1.325702 |
| hamming | random | 3.131030 |

*(Run on 5000 samples, 20 features, 10 categories)*

## License

MIT License
iflow-mcp_johnymontana-neo4j-mcp-ecommerce 0.1.0
MCP server for an ecommerce store backed by Neo4j
Requires Python: >=3.10

# Neo4j MCP Ecommerce Server (Python)

An MCP server that exposes two tools backed by Neo4j:

- `search_customer(q: str)` — search customers by name or email
- `recommend_product(customer_id: str, limit: int = 5)` — recommend products via co-purchase

This project uses `uv` for dependency and runtime management and the official Python MCP SDK.

## Prerequisites

- Python 3.10+
- `uv` installed (see docs: https://docs.astral.sh/uv/)
- A running Neo4j database

## Setup

```bash
cd python
# (optional) create and activate a project venv
uv venv && source .venv/bin/activate

# install dependencies
uv sync

# configure environment
cp env.example .env
# edit .env with your credentials
```

Required environment variables:

- `NEO4J_URI` (e.g. `bolt://localhost:7687`)
- `NEO4J_USERNAME`
- `NEO4J_PASSWORD`
- `NEO4J_DATABASE` (optional; defaults to Neo4j driver default)

## Run the MCP server

The server runs with stdio transport (standard for MCP servers):

```bash
uv run neo4j-mcp-ecommerce
```

The server communicates over stdio and can be used with MCP clients like Claude Desktop or the MCP Inspector.

## Testing with MCP Inspector

You can test the server using the MCP Inspector, a web-based tool for debugging MCP servers:

1. Run the MCP Inspector:
```bash
npx @modelcontextprotocol/inspector
```

2. In the inspector interface:
   - Click "Add Server"
   - Choose "Command" as the transport
   - Set the command to: `uv run neo4j-mcp-ecommerce`
   - Set the working directory to: `/path/to/your/python/directory`
   - Click "Connect"

3. Once connected, you can:
   - View available tools (`search_customer` and `recommend_product`)
   - Test tool calls with sample parameters
   - Inspect responses and debug any issues

The inspector provides a convenient way to test your MCP server without needing a full MCP client setup.

## Tools

### search_customer
- **Input**: `q` — substring to match name or email (case-insensitive)
- **Output**: list of customer maps: `{ id, nodeId, name, email }`

### recommend_product
- **Input**: `customer_id` — your domain identifier on `:Customer {id: ...}`
- **Input**: `limit` — max recommendations (default 5)
- **Output**: list of `{ productId, title, score }`

## Notes
- Credentials are read from environment variables (dotenv is supported for local dev).
- Cypher assumes labels/properties: `:Customer {id, name, email}` and `:Product {id, title}` with relationships approximating PURCHASED/CONTAINS/PRODUCT. Adjust queries to match your schema if different.
layrz-sdk 4.2.9
Layrz SDK for Python
Requires Python: >=3.13
Keywords: sdk, goldenm, lcl, layrz compute language, layrz

# Layrz SDK

Managed by Golden M, Inc.

## Description

It's a group of tools/classes/SDKs that can be help you to implement scripts into Layrz modules, or
incorporate them into your own projects.

## Requirements

This library uses at least Python 3.13 or higher or golang 1.25.5 or higher.

If you want to encrypt MS Excel files, you need to have the [`msoffice`](https://github.com/herumi/msoffice) utility installed in your system.

## Documentation

It's available in our documentation site [developers.layrz.com](https://developers.layrz.com/Kits/Sdk)

## Work with us

Golden M is a software/hardware development company what is working on
a new, innovative and disruptive technologies.

For more information, contact us at [sales@goldenm.com](mailto:sales@goldenm.com)

## License

This project is under MIT License, for more information, check out the `LICENCE`

## Golang support

We're currently working to add Go support to this SDK. Stay tuned for updates!