semvec/pypi-packages huggingface dataset:
airflow-mcp-plugin 0.2.0
Apache Airflow 3 plugin that mounts airflow-mcp-server as a Streamable HTTP endpoint at /mcp
Requires Python: >=3.10

# airflow-mcp-plugin

Airflow 3 plugin that mounts `airflow-mcp-server` as a Streamable HTTP endpoint at `/mcp` on the Airflow API server.

Requirements:
- Apache Airflow >= 3.0 (FastAPI backend)
- Python >= 3.10

Install (recommended via main package extra):
```bash
pip install "airflow-mcp-server[airflow-plugin]"
```

Or install the plugin directly:
```bash
pip install airflow-mcp-plugin
```

Deploy:
- Install into the Airflow webserver container environment (Docker/Compose/Helm)
- Restart the webserver; Airflow auto-loads the plugin via entry point

Use (stateless):
- Endpoint: `http(s)://<airflow-host>/mcp`
- Every request must include header: `Authorization: Bearer <access-token>`
- The token is forwarded per-request to Airflow APIs (no shared auth state)
- Mode per-request:
  - Safe (default): `http(s)://<airflow-host>/mcp`
  - Unsafe: `http(s)://<airflow-host>/mcp/?mode=unsafe` (enables POST/PUT/DELETE/PATCH)
  - Streamable HTTP (stateless)

### Usage with Claude Desktop

Claude Desktop requires a helper wrapper to forward headers. Add the plugin endpoint via [`mcp-remote`](https://github.com/geelen/mcp-remote) inside `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "airflow-mcp-plugin": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8080/mcp",
        "--header",
        "Authorization:${MCP_AIRFLOW_TOKEN}"
      ],
      "env": {
        "MCP_AIRFLOW_TOKEN": "Bearer <access-token>"
      }
    }
  }
}
```

See [`CONFIG.md`](CONFIG.md) for additional MCP client configuration examples. All clients must supply the `Authorization: Bearer <token>` header and connect over HTTP.

### Usage with VS Code

Add the server definition to your `settings.json` under the `mcp.servers` block:

```json
"mcp": {
  "servers": {
    "airflow-mcp-plugin": {
      "type": "http",
      "url": "http://localhost:8080/mcp/",
      "headers": {
        "Authorization": "Bearer <access-token>"
      }
    }
  }
}
```

This configuration uses VS Code's native HTTP transport with per-request `Authorization` headers; update the URL if your Airflow instance is hosted elsewhere.
dbbasic-email 1.0.0
Simple email queue with Unix mail support
Requires Python: >=3.6
Keywords: email, smtp, mail, queue, unix mail, mbox

# dbbasic-email

Simple email queue with Unix mail support.

> "Email is Unix mail. Queuing is sendmail. Templates are heredocs."

## Features

- **Local Mail**: Unix-style mailboxes for internal notifications (instant delivery)
- **External Email**: SMTP delivery via dbbasic-queue (async, retry logic)
- **Simple Templates**: Plain text templates with string formatting
- **Zero Config**: Works with localhost SMTP out of the box
- **Minimal**: ~200 lines, stdlib only (queue optional)

## Installation

```bash
pip install dbbasic-email
```

For external email (SMTP queue):
```bash
pip install dbbasic-email[queue]
```

## Quick Start

### Local Mail (Internal Notifications)

```python
from dbbasic_email import mail

# Send to user on same app
mail('john', 'New comment', 'Jane commented on your post')
# → Appends to var/mail/john (instant)

# Read mailbox
from dbbasic_email import read_mail
messages = read_mail('john', limit=20)
for msg in messages:
    print(f"{msg['subject']}: {msg['body']}")
```

### External Email (SMTP)

```python
from dbbasic_email import send_email

# Queue for delivery
job_id = send_email(
    to='user@gmail.com',
    subject='Welcome!',
    body='Thanks for signing up'
)
# Returns immediately (queued)
```

### Templates

```python
from dbbasic_email import send_template

# templates/email/welcome.txt
send_template('user@gmail.com', 'welcome', {
    'username': 'john',
    'app_url': 'https://myapp.com'
})
```

## Configuration

Set environment variables for SMTP:

```bash
export SMTP_HOST=smtp.gmail.com
export SMTP_PORT=587
export SMTP_USER=your@gmail.com
export SMTP_PASSWORD=your-app-password
export FROM_ADDR=noreply@myapp.com
```

For local development:
```bash
python -m smtpd -n -c DebuggingServer localhost:1025
export SMTP_HOST=localhost SMTP_PORT=1025
```

## CLI Commands

```bash
# Send local mail
dbbasic email:local john "Test" "Hello from CLI"

# View inbox
dbbasic email:inbox john

# Send external email (queued)
dbbasic email:send user@example.com "Hello" "Test"

# View queue status
dbbasic email:queue

# Run worker (process SMTP queue)
dbbasic email:worker
```

## How It Works

### Local Mail (Unix-style)

```
mail('john', subject, body)
  ↓
Append to var/mail/john (mbox format)
  ↓
Instant delivery
```

### External Email (SMTP)

```
send_email(to, subject, body)
  ↓
Queue via dbbasic-queue
  ↓
Worker picks up
  ↓
Send via SMTP (with retries)
```

## Philosophy

Email is **not a cloud service**. Unix had local mail working in 1971. The web made it complicated. Let's return to simplicity.

- **Unix Mail First**: Local delivery to var/mail/{user}
- **SMTP When Needed**: External email via SMTP (like sendmail)
- **Queue Integration**: Uses dbbasic-queue for async delivery
- **Plain Text First**: Templates are just string formatting
- **No Service Required**: Works without external email service

## Full Documentation

See the [specification](http://dbbasic.com/email-spec) for complete details.

## License

MIT