semvec/pypi-packages huggingface dataset:
cf-basic-signal 0.1.13
Cogniflow basic signal+IO step package (InlineSource, HandleSink, FIFO/average) with optional C++ acceleration.
Requires Python: >=3.10

# cf.basic.signal StepPackage

Basic IO + signal-processing steps packaged for Cogniflow (InlineSource, HandleSink, FIFO buffer, averages, optional OPC UA source).

## Steps
- `cf:InlineSource` - emit inline payload (JSON if prefixed with inline://)
- `cf:HandleSinkStep` - stub sink that forwards to a handle (duckdb://, parquet://, inline://, etc.)
- `cf:FifoWindowBufferStep` - windowed buffer
- `cf:AverageStep` - arithmetic / geometric / harmonic mean
- `cf:OpcuaPhSource` - virtual OPC UA pH source

## Files
- `cf-step-package.yaml` - manifest
- `steps.ttl` - ontology fragment for the steps
- `cf_basic_signal/steps.py` - implementations (with optional C++ backend for signal ops)
- `examples/inline_to_sink.json` - minimal IO pipeline (InlineSource -> HandleSinkStep)
- `examples/golden_fifo_avg.json` - minimal signal pipeline (InlineSource -> FIFO -> Average)

## Pipeline backend plugin

The package now registers itself as a `pipeline_backend` plugin:
- C++ ops (impl="cpp"): `fifo_window_buffer`, `average`, `csv_sink` (registered via capsule `register_cpp_op`)
- Optional C++ op (impl="cpp", gated by build flag + open62541): `opcua_ph_source`
- Python ops (impl="python"): `inline_source`, `handle_sink`, `opcua_ph_source`

To enable the C++ OPC UA op at build time, set `CF_BASIC_SIGNAL_ENABLE_OPCUA_CPP=1` and make sure
`open62541` headers/libs are discoverable (or point to them via `CF_BASIC_SIGNAL_OPEN62541_INCLUDE` /
`CF_BASIC_SIGNAL_OPEN62541_LIB` / `CF_BASIC_SIGNAL_OPEN62541_LIBNAME`).
- Metadata: `pipeline_plugin.json` (api_version=1, Data ABI `Data-v1`)
- Importing `cf_basic_signal` will auto-register C++ ops when available; otherwise the Python fallbacks are registered.

## Quick check
1) Install package:
```python
from core.step_package_manager import StepPackageManager
m = StepPackageManager("path/to/gui_sandbox.duckdb")
m.install_from_manifest("sand_toys/cf_basic_steps/cf_basic_signal/cf_basic_signal/cf-step-package.yaml")
```
2) Load server and verify:
```python
from core.algorithm_server import AlgorithmServer
s = AlgorithmServer("path/to/gui_sandbox.duckdb")
assert s.step_registry.has_step("cf:InlineSource")
assert s.step_registry.has_step("cf:HandleSinkStep")
assert s.step_registry.has_step("cf:FifoWindowBufferStep")
assert s.step_registry.has_step("cf:AverageStep")
```
3) Run the example pipelines via your runner. Expected outputs:
   - inline_to_sink: status `"handled via inline://dev-null"`
   - golden_fifo_avg: window `[4,5,6]`, mean `5.0`, small SE.

## Wheel builds & publishing
- Wheels are built with `cibuildwheel` for CPython 3.9-3.12 across Windows, Linux, and macOS (config in `pyproject.toml`).
- The workflow builds the single `cf-basic-signal` wheel (now including IO steps) and uploads it as an artifact.
- PyPI/TestPyPI publishing happens on tagged pushes via the trusted publisher action (`pypa/gh-action-pypi-publish`).
iflow-mcp_enterprise-mcp-server 0.1.0
A Model Context Protocol (MCP) server implementation that provides deployed CrewAI workflows
Requires Python: >=3.12

# CrewAI Enterprise MCP Server

## Overview

A Model Context Protocol (MCP) server implementation that provides deployed CrewAI workflows. This server enables kicking off your deployed crew and inspect the status giving the results of your crew.

## Tools

- kickoff_crew
- get_crew_status

## Env Variables

retrieve from app.crewai.com
`MCP_CREWAI_ENTERPRISE_SERVER_URL`
`MCP_CREWAI_ENTERPRISE_BEARER_TOKEN`

# Usage with Claude Desktop

![Claude Desktop with CrewAI Enterprise MCP Server](assets/tools.jpg)
![Claude Desktop with CrewAI Enterprise MCP Server](assets/kickoff.jpg)
![Claude Desktop with CrewAI Enterprise MCP Server](assets/status.jpg)

To use this MCP server with Claude Desktop, follow these steps:

1. Open Claude Desktop
2. Go to Settings > Developer Settings
3. Add a new MCP server with the configuration shown below

## Locally, cloned repo:

Install `mcp` and `mcp[cli]` locally

```json
{
  "mcpServers": {
    "crewai_enterprise_server": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp[cli]",
        "mcp",
        "run",
        "<filepath of cloned repo>",
        "/crewai_enterprise_server.py"
      ],
      "env": {
        "MCP_CREWAI_ENTERPRISE_SERVER_URL": "<>",
        "MCP_CREWAI_ENTERPRISE_BEARER_TOKEN": "<>"
      }
    }
  }
}
```

## TODO: Added on PyPI:
iflow-mcp_mcp-audio 0.1.0
MCP server for audio transcription using SiliconFlow API
Requires Python: >=3.8

# MCP-Audio Plugin

`mcp-audio` is an AIO-2030 compliant MCP plugin that performs voice-to-text transcription using the Audio speech recognition API.

It exposes the `identify_voice` method via both `multipart/form-data` and `base64` formats, supports the AIO `tools.call` protocol, and returns JSON-RPC structured outputs.

---

## Features

- Fully AIO-compliant MCP plugin (`/tools.call`, `/help`)
- Converts `.wav`/`.mp3` audio files to transcripts using SiliconFlow
- API key managed securely via `.env` file
- Docker-compatible and minimal dependencies
- Registration-ready for AIO endpoint registry

---

##  Setup (Local)

### 1. Clone and Install

```bash
git clone git@github.com:AIO-2030/mcp-audio.git
cd mcp-audio
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
```

### 2. Add .env file
```bash
cp .env.example .env
```

Set your audio URL and API key:

```
AUDIO_URL=https--xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
```

### 3. Run the MCP server

```bash
python src/mcp_server.py
```

### 4. Docker

#### 4.1 Build and Run
```bash
docker build -t mcp-audio .
docker run --env-file .env -p 8080:8080 mcp-audio
```

## API Overview

### POST /api/v1/mcp/voice_model

Upload audio file directly. Response:

```json
{
  "transcript": "hello world",
  "confidence": 0.91,
  "audio_hash": "a1b2c3..."
}
```

### POST /api/v1/mcp/tools.call (AIO Protocol)

JSON-RPC format with base64-encoded audio. Response:

```json
{
  "method": "tools.call",
  "params": {
    "method": "identify_voice",
    "inputs": [
      {
        "type": "audio",
        "value": "<base64-audio>"
      }
    ]
  }
}
```

### GET /api/v1/mcp/help
Auto-serves contents of mcp_audio_registration.json. Used by Queen AI for MCP discovery and service indexing.

## Testing Tools

### Base64 Voice Test
```bash
python test/test_audio_base64.py
```

### Health Check
```bash
python health_check.py
```

## MCP Registration (to AIO Endpoint Canister)
```bash
./register_mcp.sh
```
Requires jq, dfx, and a running endpoint_registry canister.