Anil-matcha/awesome-muse-connectors

# <Display Name>

## Purpose
<What this connector does and when Muse should reach for it.>

## Tooling
<Exact CLI commands with copy-pasteable examples. Only documented commands exist.>
```bash
bin/<name>.py <command> [--flags]
```

## Auth
- Provider id: `<provider-id>` (credential is collected as `custom.<provider-id>`)
- Collection: <API key | provider OAuth> via the secure credential flow (`credentials.request_api_access`)

# Airtable

## Purpose
Work the user's Airtable: list bases (`bases`), read table records (`records`), and add a record (`create`).

## Tooling
All commands go through `bin/airtable.py`:

```bash
bin/airtable.py bases                                            # list bases (name, id)
bin/airtable.py records --base appABC --table "Tasks"            # read records (flattened fields), 10 max
bin/airtable.py records --base appABC --table "Tasks" --limit 50
bin/airtable.py create --base appABC --table "Tasks" --fields '{"Name": "Buy milk"}'
```

# Alpha Vantage

## Purpose
Read-only stock market data: latest quote for a symbol and the last 5 daily closes. Use when the user asks for a stock quote, a stock price, or mentions Alpha Vantage.

## Tooling
All commands go through `bin/alphavantage.py`:

```bash
bin/alphavantage.py quote --symbol IBM    # latest quote
bin/alphavantage.py daily --symbol AAPL   # last 5 daily closes
```

## Auth

# Amadeus

## Purpose
Search travel with Amadeus Self-Service APIs: flight offers with prices, airport/city autocomplete, hotel offers, cheapest dates. This connector covers search plus pricing: it returns offers and prices, but it does not book tickets. Use when the user wants to search flights or hotels.

## Tooling
All commands go through `bin/amadeus.py`:

```bash
bin/amadeus.py auth                                        # verify the token (test env)
bin/amadeus.py locations --keyword "London"               # airport/city autocomplete
bin/amadeus.py flight-offers --origin JFK --destination LHR --departure-date 2026-10-01 --return-date 2026-10-08
bin/amadeus.py hotel-offers --hotel-ids HTPAR001 --check-in 2026-10-01 --check-out 2026-10-03
bin/amadeus.py flight-dates --origin JFK --destination LHR --departure-date 2026-10-01 --duration 7

# Anthropic

## Purpose
Check that the user's Anthropic API key works and list the models available to it (id, display name). Read-only by design: this skill never spends credits; it ships no message, token-count, or other billable calls.

## Tooling
All commands go through `bin/anthropic.py`:

```bash
bin/anthropic.py models    # list models available to this key (id, display_name)
```

## Auth
- Provider id: `anthropic` (credential is collected as `custom.anthropic`)

# Apollo

## Purpose
Search B2B contacts with Apollo.io: search people by title, location, and company; enrich a person or a company. Use when the user mentions Apollo, prospecting, or wants contact/company data enriched.

## Tooling
All commands go through `bin/apollo.py`:

```bash
bin/apollo.py auth                                      # verify the API key
bin/apollo.py search --titles "VP Sales" --domains "acme.com" --limit 10  # search people
bin/apollo.py enrich --email "jane@acme.com"            # enrich one person (uses credits)
bin/apollo.py org-enrich --domain "acme.com"            # enrich one company
```

# Aqara

## Purpose
Read device attributes and send control commands to Aqara devices through the
Aqara Open Cloud API: plugs and wall switches, lights (brightness, color
temperature), air conditioners, supported locks, curtain motors, and saved
scenes, organized by homes and rooms. Use it when the user asks about or wants
to change anything in their Aqara setup. Zigbee devices need an Aqara hub
online. Commands drive real physical hardware, so writes are
confirmation-gated (see Operating Rules).

## Tooling
All commands go through `bin/aqara.py`. `--region` picks the regional host
(`open-<region>.aqara.com`, e.g. `us`, `eu`, `cn`; default `us`).

# Asana

## Purpose
Work with the user's Asana: view tasks assigned to them and create new tasks. Use when the user mentions Asana, their tasks, or a todo list.

## Tooling
All commands go through `bin/asana.py`:

```bash
bin/asana.py me                                        # verify the connection, shows user gid
bin/asana.py tasks                                     # tasks assigned to me
bin/asana.py create --name "Ship v2" --notes "details"  # create a task
bin/asana.py create --name "Ship v2" --workspace-gid 1234567890123456 --notes "x"
```

# Ashby

## Purpose
Two modes in one connector. (1) Credential-free public job search: list any Ashby-powered company's public job board with no API key. (2) Authenticated ATS for hiring teams: list candidates, jobs, and applications; create applications and move them through the pipeline. Most users will only need the public feed.

## Tooling
All commands go through `bin/ashby.py`:

```bash
bin/ashby.py jobs-public --org acme                        # public job board (no credential needed)
bin/ashby.py auth                                          # verify the ATS API key
bin/ashby.py candidate-list --json '{}'                    # list candidates
bin/ashby.py job-list --json '{}'                          # list jobs
bin/ashby.py application-list --json '{}'                  # list applications/pipeline

# Attio

## Purpose
Read and write the user's Attio CRM: list objects, query records on any object, create-or-update records, add notes and tasks to records. Use when the user mentions Attio or their CRM.

## Tooling
All commands go through `bin/attio.py`:

```bash
bin/attio.py auth                                     # verify the API key
bin/attio.py objects                                  # list available objects
bin/attio.py query --object-slug companies --filter-json '{"filters":[]}'  # query records
bin/attio.py upsert --object-slug companies --match-attribute email --values-json '{"name":[{"value":"Acme"}],"email":[{"value":"a@acme.com"}]}'  # create or update a record
bin/attio.py note --record-id rec_abc123 --title "Call notes" --content "Discussed pricing"  # add a note

# Beatoven.ai

## Purpose
Compose royalty-free music with Beatoven's public composition API: text-to-music (also audio-to-music and video-to-music prompts), task polling, track download, and individual stems (bass, chords, melody, percussion), plus SFX via the maestro model. Beatoven is Fairly Trained certified (licensed training data), so output is commercially safe, and it is the only verified self-serve music API in the catalog (Suno and Udio have no public APIs). Also available on the fal.ai marketplace.

## Tooling
All commands go through `bin/beatoven.py`:

```bash
bin/beatoven.py auth                                                      # verify credential setup (no spend)
bin/beatoven.py compose --prompt "30 seconds peaceful lo-fi chill hop track" --format wav
bin/beatoven.py compose --prompt "upbeat podcast intro" --format mp3 --looping
bin/beatoven.py status --task-id <task_id>                                # poll until composed
bin/beatoven.py download --task-id <task_id> --out track.wav              # download the composed track

# Beehiiv

## Purpose
Read and write the user's beehiiv newsletters: list publications, list subscribers, list posts with stats, add subscribers. Use when the user mentions beehiiv or their newsletter.

## Tooling
All commands go through `bin/beehiiv.py`:

```bash
bin/beehiiv.py auth                                     # verify the API key
bin/beehiiv.py publications                             # list publications
bin/beehiiv.py subscriptions --pub pub_abc123 --limit 25  # list subscribers
bin/beehiiv.py posts --pub pub_abc123 --limit 25        # list posts with stats
bin/beehiiv.py subscribe --pub pub_abc123 --email "them@example.com"  # add a subscriber

# FLUX image API

## Purpose
Generate images with the FLUX.2 family via Black Forest Labs' official API: `flux-2-pro` for general text-to-image and native image editing, `flux-2-flex` for typography and text-heavy images. The quality bar for custom imagery in the catalog. Regional hosts exist for GDPR (`api.eu.bfl.ai`) and US (`api.us.bfl.ai`).

## Tooling
All commands go through `bin/black-forest-labs.py`:

```bash
bin/black-forest-labs.py auth                                             # verify credential setup (no spend)
bin/black-forest-labs.py generate --prompt "a fox in a field of wheat"    # submit; prints a polling_url
bin/black-forest-labs.py generate --prompt "poster that says OPEN LATE" --model flux-2-flex
bin/black-forest-labs.py generate --prompt "..." --region https://api.eu.bfl.ai
bin/black-forest-labs.py status --polling-url 'https://api.bfl.ai/v1/get_result?id=...'   # poll until Ready

# Bluesky

## Purpose
Read and write the user's Bluesky account through the AT Protocol (XRPC): view profiles and the home timeline, search posts, create posts, follow accounts, and list notifications. Use when the user mentions Bluesky or atproto.

## Tooling
All commands go through `bin/bluesky.py`. Every command takes a required `--handle` (the account handle, e.g. `me.bsky.social`):

```bash
bin/bluesky.py auth --handle me.bsky.social                  # verify the session
bin/bluesky.py profile --handle me.bsky.social               # view a profile (add --target to view someone else)
bin/bluesky.py timeline --handle me.bsky.social              # home timeline
bin/bluesky.py search --handle me.bsky.social --query "agents"  # search posts
bin/bluesky.py post --handle me.bsky.social --text "hello world"  # publish a post (confirm first)

# Brave Search

## Purpose
Read-only web search powered by Brave's own independent index. Use when the user mentions Brave or asks for a web search.

## Tooling
All commands go through `bin/brave-search.py`:

```bash
bin/brave-search.py auth                                  # verify the connection
bin/brave-search.py search --query "AI agent frameworks" --count 10   # web search
```

## Auth

# Buttondown

## Purpose
Read and write the user's Buttondown newsletter: list subscribers, list emails (drafts and sent), add subscribers, create email drafts. Use when the user mentions Buttondown or their newsletter.

## Tooling
All commands go through `bin/buttondown.py`:

```bash
bin/buttondown.py auth                                      # verify the API key
bin/buttondown.py subscribers --limit 25                    # list subscribers
bin/buttondown.py subscriber-add --email "them@example.com" # add a subscriber
bin/buttondown.py emails --limit 25                         # list emails
bin/buttondown.py email-create --subject "Hi" --body "..."   # create a draft email

# Buzzsprout

## Purpose
Manage podcast episodes on Buzzsprout: list and fetch episodes, create, update, or delete them, and list embed players. Use when the user wants to publish or manage podcast episodes on a Buzzsprout-hosted show.

## Tooling
All commands go through `bin/buzzsprout.py`. Every command takes `--podcast-id` because the podcast id is part of the API path:

```bash
bin/buzzsprout.py auth --podcast-id 12345                                  # verify the API token
bin/buzzsprout.py episodes --podcast-id 12345                              # list episodes
bin/buzzsprout.py episode-get --podcast-id 12345 --episode-id 6789         # get one episode
bin/buzzsprout.py episode-create --podcast-id 12345 \
    --payload '{"title":"Ep 12","description":"...","audio_url":"https://..."}'  # create (confirm first)

# Cal.com

## Purpose
Read and write the user's Cal.com scheduling: list bookings, list event types, create bookings. Use when the user mentions Cal.com, their bookings, or wants a meeting scheduled.

## Tooling
All commands go through `bin/calcom.py`:

```bash
bin/calcom.py auth                                      # verify the API key
bin/calcom.py bookings --limit 25                       # list bookings
bin/calcom.py bookings --status cancelled --limit 25    # filter by status
bin/calcom.py event-types                               # list event types
bin/calcom.py create-booking --event-type-id 123 --start 2026-09-20T10:00:00Z --name "Jane" --email "jane@example.com"

# Calendly

## Purpose
Read and manage the user's Calendly: list upcoming scheduled events, event types, invitees for an event, and availability schedules; cancel bookings. Use when the user mentions Calendly, their bookings, or meeting links.

## Tooling
All commands go through `bin/calendly.py`:

```bash
bin/calendly.py auth                                          # verify the token, shows your user URI
bin/calendly.py scheduled-events --user https://api.calendly.com/users/ABC123 --count 20
bin/calendly.py event-types --user https://api.calendly.com/users/ABC123
bin/calendly.py invitees --event-uuid abc123                # invitees for one event
bin/calendly.py availability --user https://api.calendly.com/users/ABC123

# Canva

## Purpose
Read and manage Canva designs through the Canva Connect API: list designs and folders, inspect a design, create designs, upload assets, and export designs. Exports are async jobs: submit with `export`, then poll with `export-status` until the job succeeds.

## Tooling
All commands go through `bin/canva.py`:

```bash
bin/canva.py auth                                        # verify the connection (prints the Canva user)
bin/canva.py designs --query "pitch deck"                # list designs, optional search
bin/canva.py design --id DESIGN_ID                      # get one design's details
bin/canva.py folders                                     # list folders
bin/canva.py folder-items --id FOLDER_ID                 # list items in a folder

# Cartesia

## Purpose
Generate spoken audio from text with Cartesia's Sonic models (40+ languages) and browse the Cartesia voice library. Reach for this when the user wants narration, voiceovers, or spoken-audio files produced from a script.

## Tooling
All commands go through `bin/cartesia.py`. Every request automatically sends the required date header `Cartesia-Version: 2026-08-14`.

```bash
bin/cartesia.py auth
# {"ok": true, "voices": 60} on success

bin/cartesia.py voices
# list available voices (id, name, language)

# Clerk

## Purpose
Manage users in the user's Clerk application through the Clerk Backend API: list users, look up one user, create users, update names, and delete users. Use when the user mentions their Clerk users.

## Tooling
All commands go through `bin/clerk.py`:

```bash
bin/clerk.py auth                                                    # verify the secret key
bin/clerk.py users --limit 25                                        # list users
bin/clerk.py user --id <user-id>                                     # look up one user
bin/clerk.py create --email "them@example.com" --first-name Ana      # create a user
bin/clerk.py update --id <user-id> --last-name Reyes                 # update a user

# ClickUp

## Purpose
Work the user's ClickUp: list workspaces ("teams") (`teams`), list tasks in a list (`tasks`), and create tasks (`create`). ClickUp's API calls workspaces "teams": `teams` returns workspaces.

## Tooling
All commands go through `bin/clickup.py`:

```bash
bin/clickup.py teams                    # workspaces (id, name)
bin/clickup.py tasks --list 123456789   # tasks in a list (name, status, due date)
bin/clickup.py create --list 123456789 --name "Ship the thing"   # create a task
```

# Cloudflare

## Purpose
Read-only visibility into the user's Cloudflare account: list zones (domains) and read the DNS records for a zone. Use when the user asks about their domains, DNS, or Cloudflare setup.

## Tooling
All commands go through `bin/cloudflare.py`:

```bash
bin/cloudflare.py zones                 # list zones (name, status)
bin/cloudflare.py dns --zone ZONE_ID    # DNS records for a zone (type, name, content)
```

## Auth

# Cloudinary

## Purpose
Manage media on Cloudinary through the Upload and Admin APIs: upload images and videos, list and inspect assets, update metadata and tags, delete assets, and check plan usage (credits, storage, bandwidth, transformations).

## Tooling
All commands go through `bin/cloudinary.py`:

```bash
bin/cloudinary.py auth                                        # verify the connection (also shows plan usage)
bin/cloudinary.py usage                                       # plan usage: credits, storage, bandwidth, transformations
bin/cloudinary.py upload --file ./photo.jpg                  # upload an image
bin/cloudinary.py upload --file ./clip.mp4 --resource-type video   # upload a video
bin/cloudinary.py upload --file ./photo.jpg --folder products # upload into a folder

# Coda

## Purpose
Read and write the user's Coda workspace: list docs, list tables in a doc, read table rows, add rows to a table. Use when the user mentions Coda, a Coda doc, or a Coda table.

## Tooling
All commands go through `bin/coda.py`:

```bash
bin/coda.py auth                                        # verify the token (whoami)
bin/coda.py docs --limit 25                             # list docs
bin/coda.py tables --doc DOC_ID                         # list tables in a doc
bin/coda.py rows --doc DOC_ID --table TABLE_ID          # read rows from a table
bin/coda.py add-row --doc DOC_ID --table TABLE_ID --cells '{"Task":"Ship","Done":false}'  # add a row

# Cohesivity

## Purpose

Cohesivity is on-the-fly infrastructure for AI agents. One HTTP API provisions databases, hosting, auth, realtime, storage, email, and AI model access. No per-vendor consoles, no copied keys.

Use when a task needs one or more of these services and the agent should carry the build from setup through deployment. Do not use when the user has chosen a competing provider or the needed service is absent from the catalog below.

Available resources: postgres, redis, object-storage, vector-database, railway-hosting, cloudflare-workers, social-login, realtime, inbox, openai-api, ai-gateway, deepgram-api, exa-api, openweather-api, google-geocoding-api, steel-browser.

Two planes:

[Credential-related source omitted]
2. **Data plane** (`https://cohesivity.ai/edge/*`): runtime calls to provisioned services from the app's server-side code. Auth: `?key=<coh_application_key>` or a short-lived token from `POST /edge/session?key=<coh_application_key>`.

# Datacircle

## Purpose
Datacircle is a data co-op. Query your favorite B2B data APIs through us. Same request, same price, no markup. Right now we have 3 live LinkedIn profile APIs that we trust: Up2Data, HarvestAPI and Fetchin.

Use it when the user gives a LinkedIn profile URL and wants that person's profile (role, company, history, skills), or asks for their Datacircle balance. Each request goes to the provider and gets the profile as it is today.

## Tooling
All commands go through `bin/datacircle.py`:

```bash
bin/datacircle.py auth                      # verify the connection
bin/datacircle.py balance                   # the balance in dollars, free
bin/datacircle.py profile --url https://www.linkedin.com/in/williamhgates             # prints the price, looks nothing up

# Deepgram

## Purpose
Transcribe prerecorded audio files to text (with optional diarization, summaries, topics, sentiment) and synthesize speech with Deepgram's Aura voices. Reach for this when the user has an audio file to transcribe or wants spoken audio generated from text.

## Tooling
[Credential-related source omitted]

```bash
bin/deepgram.py auth
# {"ok": true, "projects": 2} on success

bin/deepgram.py projects
# list Deepgram projects (id, name)

# DeepL

## Purpose
Translate text with DeepL: translate between 30+ languages with optional formality control, list supported languages, check character usage. Use when the user mentions DeepL or wants text translated.

## Tooling
All commands go through `bin/deepl.py`:

```bash
bin/deepl.py auth                                        # verify the key and show usage
bin/deepl.py translate --text "Hello" --target-lang FR  # translate text
bin/deepl.py translate --text "Hello" --target-lang DE --source-lang EN --formality more
bin/deepl.py languages                                  # list supported target languages
```

# DeepSeek

## Purpose
Call the DeepSeek API from Muse: list the currently available models, run OpenAI-compatible chat completions (with thinking mode and sampling controls), and check the account balance. Reach for this when the user wants an answer from a DeepSeek model or wants to inspect their DeepSeek account.

## Tooling
All commands go through `bin/deepseek.py`:

```bash
bin/deepseek.py auth                                              # verify the API key
bin/deepseek.py models                                            # list available models
bin/deepseek.py chat --message "Explain recursion in one sentence" \
    --model deepseek-flash                                        # chat completion (SPENDS)
bin/deepseek.py chat --message "Solve: 2x+5=17" \

# Descript

## Purpose
Work with Descript's API (open beta): list projects, inspect Underlord/agent jobs, submit a publish job, and poll a job until it finishes. Use when the user wants to drive Descript editing or publishing programmatically.

## Tooling
All commands go through `bin/descript.py`:

```bash
bin/descript.py auth                                   # verify the API key
bin/descript.py projects                               # list projects
bin/descript.py project --id PROJECT_ID                # get one project
bin/descript.py jobs                                   # list Underlord/agent jobs
bin/descript.py job-status --id JOB_ID                 # get job status once

# Dev.to

## Purpose
Read and write the user's dev.to account: own profile, own articles (published, unpublished drafts, or all), public articles by any username, create articles (draft by default), update articles. Use when the user mentions dev.to, a blog post, or publishing an article.

## Tooling
All commands go through `bin/devto.py`:

```bash
bin/devto.py me                                                      # verify the API key
bin/devto.py my-articles                                             # published articles
bin/devto.py my-articles --state all                                 # published + drafts
bin/devto.py articles-by-user --username ben                         # public reads, no key needed
bin/devto.py article-create --title "My post" --body-markdown "..." --tags "ai,python"  # draft by default

# DigitalOcean

## Purpose
Read-only visibility into the user's DigitalOcean account: list droplets (name, status, region) and domains. Use when the user asks what servers or domains they have on DigitalOcean.

## Tooling
All commands go through `bin/digitalocean.py`:

```bash
bin/digitalocean.py droplets   # droplets (name, status, region)
bin/digitalocean.py domains    # domains (name)
```

## Auth

# Discord

## Purpose
[Credential-related source omitted]

## Tooling
All commands go through `bin/discord.py`:

```bash
bin/discord.py auth                                   # verify the bot token
bin/discord.py guilds                                 # list servers the bot joined
bin/discord.py channels --guild 112233445566778899    # list channels in a server
bin/discord.py history --channel 112233445566778899 --limit 25  # read recent messages
bin/discord.py send --channel 112233445566778899 --text "Ship it"  # post a message

# DocuSign

## Purpose
Work with DocuSign's eSignature REST API v2.1: list envelopes, fetch envelope details and recipient status, prepare DRAFT envelopes (never sent automatically), send a draft envelope to signers, and download envelope documents. Every command runs against the demo environment unless you pass `--env prod`: `demo.docusign.net` sends no legally effective documents. Reach for this when the user needs to prepare, send, or track a DocuSign signature request.

## Tooling
All commands go through `bin/docusign.py`. **Demo is the default** (`--env demo`); add `--env prod` for production:

```bash
bin/docusign.py auth                                  # verify OAuth; list accounts
bin/docusign.py envelopes --from-date 2026-09-01      # list envelopes
bin/docusign.py envelope-get --envelope-id ENV_ID     # envelope details
bin/docusign.py envelope-status --envelope-id ENV_ID  # status + recipient state
bin/docusign.py envelope-create --file envelope.json \

# Dub

## Purpose
Manage Dub short links: list links, create new ones, update or delete them, read click analytics, and record lead or sale conversions against a click. Use when the user mentions Dub or short links.

## Tooling
All commands go through `bin/dub.py`:

```bash
bin/dub.py auth                                                  # verify the API key
bin/dub.py links --limit 25                                      # list links
bin/dub.py create --url "https://example.com/long" --key "launch"  # new short link
bin/dub.py update --id "clvabc123" --url "https://example.com/new"  # edit a link
bin/dub.py delete --id "clvabc123"                               # delete a link

# Ecovacs

## Purpose
Control Ecovacs DEEBOT robot vacuums through the official Ecovacs Open Platform: list bound robots, read robot state and battery, start/pause/resume/stop cleaning, send the robot back to its dock, and set the sweep/mop work mode. Use when the user mentions their DEEBOT or robot vacuum.

## Tooling
All commands go through `bin/ecovacs.py`. `--region` selects the Open Platform region (`global` for open.ecovacs.com, `cn` for open.ecovacs.cn; default `global`) and must match the region of the user's Ecovacs account and robots. `--robot` is the robot's nickname (a fragment of the name shown in the app is enough for the gateway to match it).

```bash
bin/ecovacs.py auth --region global                 # verify the Access Key
bin/ecovacs.py devices                              # list bound robots
bin/ecovacs.py status --robot Blue                  # cleaning/paused/docked state
bin/ecovacs.py battery --robot Blue                 # battery percent
bin/ecovacs.py stats --robot Blue                   # area cleaned, duration

# Elai

## Purpose
Build AI avatar presenter videos with Elai: list available avatars, inspect videos and their render status, submit renders, and poll until a render finishes. Reach for this when the user wants a talking-head video generated from a script or slide deck.

## Tooling
All commands go through `bin/elai.py`.

```bash
bin/elai.py auth
# {"ok": true, "avatars": 40} on success

bin/elai.py avatars
# list available avatars (code, name, gender)

# ElevenLabs

## Purpose
Work with the user's ElevenLabs account: subscription tier and character usage (`me`), the voices available on the account (`voices`), and text-to-speech generation (`text-to-speech`). TTS consumes characters from the account quota (real money on paid plans): it requires the exact-match `--confirm` string on every generation, stating the voice and character count.

## Tooling
All commands go through `bin/elevenlabs.py`:

```bash
bin/elevenlabs.py me        # subscription tier, character_count, character_limit
bin/elevenlabs.py voices    # available voices (name, category)

# TTS: every generation requires the exact --confirm string the CLI prints
bin/elevenlabs.py text-to-speech --text "Hello there" --voice-name Rachel --out /tmp/line.mp3

# Etsy

## Purpose
Read the user's Etsy shop: receipts (orders), active listings, transactions, and the payment-account ledger. Create listings on confirmation. Use when the user mentions Etsy, their shop, or listing management.

## Tooling
All commands go through `bin/etsy.py`; every command needs `--shop-id`:

```bash
bin/etsy.py auth --shop-id 12345678                       # verify OAuth token and keystring
bin/etsy.py receipts --shop-id 12345678 --limit 25        # list receipts (orders)
bin/etsy.py listings --shop-id 12345678 --limit 25        # list active listings
bin/etsy.py listing-create --shop-id 12345678 --json '{...}'  # create a listing (confirm first)
bin/etsy.py transactions --shop-id 12345678 --limit 25    # list transactions

# Exa

## Purpose
Read-only neural web search over Exa's index: one call returns ranked sources, and can also fetch each result's page text so the user gets snippets with substance. Use when the user mentions Exa or asks to search the web with ranked sources.

## Tooling
All commands go through `bin/exa.py`:

```bash
bin/exa.py auth                            # verify the connection
bin/exa.py search --query "Moltbook API" --limit 5   # search with page text
```

## Auth

# fal.ai

## Purpose
Run fal.ai's model marketplace: one API key unlocks hundreds of models spanning images, video, audio, voice, music (FLUX, Veo, Kling, Luma, Minimax, Wan, Stable Audio). Use when Michael asks for AI image/video/audio generation or names a specific fal model. There is also an official MCP server at https://mcp.fal.ai/mcp if an MCP route is ever preferred.

## Tooling
All commands go through `bin/fal-ai.py`:

```bash
bin/fal-ai.py auth                                                        # verify the API key (free)
bin/fal-ai.py models                                                      # list the model catalog
bin/fal-ai.py run --model fal-ai/flux-2-pro --params '{"prompt": "a lighthouse at dusk"}'   # submit a job
bin/fal-ai.py status --model fal-ai/flux-2-pro --id <request_id>           # poll the job
bin/fal-ai.py result --model fal-ai/flux-2-pro --id <request_id>           # fetch the finished result

# Figma

## Purpose
Read from the user's Figma: the authenticated user (`me`) and file metadata (`file`: name, lastModified, version, thumbnailUrl). The full file document is intentionally not returned: it is too large to be useful in chat, so `file` surfaces metadata only. The `comment` command posts a comment to a file (plain text, or anchored to a node with `--node-id`); positioned canvas pins (x/y without a node) are not supported because the exact `client_meta` schema is not clearly defined in Figma's public docs.

## Tooling
All commands go through `bin/figma.py`:

```bash
bin/figma.py me                 # authenticated user (handle, email)
bin/figma.py file --key KEY     # file metadata: name, lastModified, version, thumbnailUrl

# Comment posts need an exact --confirm string (the CLI prints the required string on refusal)
bin/figma.py comment --key KEY --message "Looks great!" \

# Firecrawl

## Purpose
Turn websites into clean data with Firecrawl: scrape a single page to markdown, start an async crawl of a whole site, poll the crawl for results, map a site's URLs, and run web search. Use when the user mentions Firecrawl or asks to scrape a website.

## Tooling
All commands go through `bin/firecrawl.py`:

```bash
bin/firecrawl.py auth                                 # verify the API key (costs one map call)
bin/firecrawl.py scrape --url "https://example.com"   # scrape one page to markdown
bin/firecrawl.py crawl --url "https://example.com"    # start a crawl; returns a job id
bin/firecrawl.py crawl-status --id "abc123"           # poll a crawl job
bin/firecrawl.py map --url "https://example.com"      # list URLs on a site

# Fly.io

## Purpose
Read and write the user's Fly.io Machines through the Fly.io Machines REST API: list apps and machines, inspect machines and volumes, create machines, stop/start/restart them, and run one-off commands inside a machine with exec. Use when the user mentions Fly.io, fly apps, or their machines.

## Tooling
All commands go through `bin/flyio.py`:

```bash
bin/flyio.py auth                                            # verify the API key
bin/flyio.py apps --org personal                             # list apps in an org
bin/flyio.py machines --app myapp                            # list machines in an app
bin/flyio.py volumes --app myapp                             # list volumes in an app
bin/flyio.py machine-create --app myapp --config-json '<config-json>'  # create a machine (confirm first)

# Framer

## Purpose
[Credential-related source omitted]

## Tooling
All commands go through `bin/framer.py`:

```bash
bin/framer.py auth --project "https://framer.com/projects/Sites--aabbccddeeff00112233"
    # verify the API key against a project (accepts a project URL or a bare project id)
```

A successful `auth` prints the handshake result (session id, mode, active branch). Deeper operations (pages, CMS collections and items, canvas nodes, asset uploads, preview deploys, production deploys, redirects) run through the official `framer-api` npm package (`npm i framer-api`), not through this CLI: the plugin RPC protocol behind the socket is not reimplemented here.

# Front

## Purpose
Work with the user's Front (shared-inbox) account: list inboxes (`inboxes`: name, address), list conversations in an inbox (`conversations`: subject, status), list teammates (`teammates`: id, name, email), and write: reply to a conversation (`reply`), assign a teammate (`assign`), and add tags (`tag`). The API token needs the `messages:send` scope for replies and `conversations:write` for assign/tag.

## Tooling
All commands go through `bin/front.py`:

```bash
bin/front.py inboxes                        # list inboxes (name, address)
bin/front.py conversations --inbox inb_123  # recent conversations (subject, status)
bin/front.py teammates                      # teammates (id, name, email)

# writes: every one requires the exact --confirm string the CLI prints

# FXMacroData

## Purpose
Read-only macroeconomic and FX data from [FXMacroData](https://fxmacrodata.com/?utm_source=github&utm_medium=referral&utm_campaign=awesome-muse-connectors&utm_content=readme): the indicator catalogue for a currency, the release history of one indicator (CPI, payrolls, policy rate, bond yields and so on, each row with its official source link), upcoming release dates, and daily FX spot rates. Use when the user asks for a macro release, an economic calendar, or an exchange rate.

Currencies: AUD, BRL, CAD, CHF, CNH, CNY, DKK, EUR, GBP, HUF, ILS, JPY, KRW, MYR, NGN, NOK, NZD, PEN, SEK, THB, TWD, USD.

Source: the public OpenAPI spec at https://api.fxmacrodata.com/openapi.json and the reference at https://fxmacrodata.com/documentation/reference, both checked on 2026-10-04.

## Tooling
All commands go through `bin/fxmacrodata.py`. Each prints the API's JSON response unchanged.

```bash
bin/fxmacrodata.py status                                   # GET /v1/health, plus which auth mode is in use

# Gemini (media generation)

## Purpose
Generate images (Nano Banana, Imagen 4), video (Veo 3.1), and speech (TTS) through Google's Gemini API with one key and one bill. Use when Michael asks for AI-generated images, video clips, thumbnails, or voiceovers via Google.

## Tooling
All commands go through `bin/gemini.py`:

```bash
bin/gemini.py auth                                                        # verify the API key (free)
bin/gemini.py models --limit 50                                           # list available models
bin/gemini.py image --prompt "a ceramic fox" --out /tmp/fox               # Nano Banana text-to-image (or edit with --image)
bin/gemini.py image --prompt "make it night" --image ./fox.png --out /tmp/fox-night
bin/gemini.py imagen --prompt "studio product shot" --count 2 --out /tmp/prod   # Imagen 4

# GitHub

## Purpose
Work with the user's GitHub account: verify identity, list repositories, list open issues, and create issues. Use when the user mentions GitHub, a repo, or wants an issue filed.

## Tooling
All commands go through `bin/github.py`:

```bash
bin/github.py auth                                              # verify the connection (GET /user)
bin/github.py repos                                             # list your repos (name, private, updated_at)
bin/github.py issues --repo OWNER/REPO                          # open issues in a repo
bin/github.py create-issue --repo OWNER/REPO --title "T" \
    --body "details"                                            # create an issue

# GitLab

## Purpose
Read and write the user's GitLab: who the token belongs to, project list, open merge requests for a project, and issue creation. Use when the user mentions GitLab, merge requests, or wants something filed as a GitLab issue.

## Tooling
All commands go through `bin/gitlab.py`:

```bash
bin/gitlab.py me                                              # verify the connection
bin/gitlab.py projects                                        # your projects
bin/gitlab.py mrs --project 123456                            # open merge requests
bin/gitlab.py create-issue --project 123456 --title "Bug: ..."  # create an issue
```

# Google Nest

## Purpose
Read traits and execute commands on Google Nest devices through the Smart
Device Management (SDM) API: thermostats (mode, setpoints, ambient readings),
cameras and doorbells (events, live-stream generation). Use it when the user
asks about their Nest thermostat, wants to change heating/cooling, or wants
camera/doorbell state. Thermostat commands start or stop real HVAC, so they
are confirmation-gated (see Operating Rules).

## Tooling
All commands go through `bin/google-nest.py`. `--project` is always the
Device Access project id:

# Gumroad

## Purpose
Read-only access to the user's Gumroad account: list products and view recent sales. Use when the user mentions Gumroad, asks about Gumroad sales, or wants to see their Gumroad products. Prices are reported in USD (the API returns cents; the CLI converts). This connector cannot change anything.

## Tooling
All commands go through `bin/gumroad.py`:

```bash
bin/gumroad.py auth             # verify the connection
bin/gumroad.py products         # list products
bin/gumroad.py sales --limit 20 # recent sales
```

# HeyGen

## Purpose
Generate talking-head and avatar videos with HeyGen's self-serve API: one-shot prompt-to-video via the Video Agent, or multi-scene avatar videos assembled from stock or custom avatars and voices. The best self-serve avatar-video path in the catalog; translation/dubbing endpoints also exist. Use when Michael wants presenter-style or explainer videos.

## Tooling
All commands go through `bin/heygen.py`:

```bash
bin/heygen.py auth                                                        # verify the API key (free)
bin/heygen.py avatars --limit 25                                          # list stock avatars (custom avatar IDs come from the app)
bin/heygen.py voices --limit 25                                           # list voices
bin/heygen.py video-agent --prompt "Explain compounding in 30 seconds"    # one-shot prompt-to-video
bin/heygen.py video-generate --json '{"avatar_id": "...", "voice_id": "...", "script": "..."}'   # multi-scene

# Home Assistant

## Purpose
Talk to the user's own Home Assistant instance: list entity states (`states`, optionally filtered by domain), read one entity (`state`), and call services (`call`: e.g. `light.turn_on`). The instance URL is passed with every command via `--instance`.

## Tooling
All commands go through `bin/home-assistant.py`:

```bash
bin/home-assistant.py --instance https://home.example.com states                  # all entity states (entity_id, state)
bin/home-assistant.py --instance https://home.example.com states --domain light   # lights only
bin/home-assistant.py --instance https://home.example.com state --entity light.living_room
bin/home-assistant.py --instance https://home.example.com call --domain light --service turn_on --entity light.living_room
bin/home-assistant.py --instance https://home.example.com call --domain climate --service set_temperature --entity climate.living_room --data '{"temperature": 22}'

# Homey

## Purpose
Read device state and write capability values on a Homey Pro (local) or Homey
cloud account through the Homey Web API: lights and outlets, dimmers and
color, thermostats, connected locks, blinds and curtains, plus listing Flows
(automations). Use it when the user asks about or wants to change anything
paired to their Homey. Writes drive real physical hardware, so they are
confirmation-gated (see Operating Rules).

## Tooling
All commands go through `bin/homey.py`. `--host` is required on every run:
the API root, either local (`http://<homey-ip>/api`) or cloud
(`https://<cloud-id>.connect.athom.com/api`):

# HTML Docs

## Purpose
Use HTML Docs as the user's collaborative artifact drive: search and read their
documents, create a private document from HTML or Markdown, edit one returned
block, and read or add review comments. Reach for it when a user wants an
AI-generated artifact to remain editable by both people and agents.

API contracts were checked against the public
[HTML Docs Collaboration API reference](https://www.html-docs.com/api/v1/help)
on 2026-10-08.

## Tooling
All commands go through `bin/html_docs.py` and return JSON:

# Hubitat

## Purpose
Read device states and invoke capability commands on a Hubitat Elevation hub
through the official Maker API app: lights and dimmers, deadbolt locks,
garage door controllers, thermostats, location modes, and the Hubitat Safety
Monitor (HSM). Use it when the user asks about or wants to change anything
paired to their Hubitat hub. Commands drive real physical hardware, so writes
are confirmation-gated (see Operating Rules).

## Tooling
All commands go through `bin/hubitat.py`. `--host` is required on every run:
the local Maker API base URL (`http://<hub-ip>/apps/api/<app-id>`) or the
cloud relay URL the Maker API app issues:

# HubSpot

## Purpose
Work with the user's HubSpot CRM: list contacts, search contacts, create contacts, and list deals. Use when the user mentions HubSpot, CRM, contacts, or their sales pipeline.

## Tooling
All commands go through `bin/hubspot.py`:

```bash
bin/hubspot.py contacts --limit 20                                  # list contacts
bin/hubspot.py search-contacts --query "acme"                       # search contacts
bin/hubspot.py create-contact --email jane@acme.com --firstname Jane --lastname Doe
bin/hubspot.py deals --limit 20                                     # list deals
```

# Hugging Face

## Purpose
Verify the user's Hugging Face account and search the public model hub: whoami (name, email), and model search by keyword with likes/downloads. Read-only: no repo writes ship in this skill.

## Tooling
All commands go through `bin/huggingface.py`:

```bash
bin/huggingface.py me                        # whoami: name, email, account type
bin/huggingface.py models --query llama      # search the model hub (id, likes, downloads), 10 results
```

## Auth

# Hume AI

## Purpose
Synthesize speech with Hume's Octave TTS models and read EVI (Empathic Voice Interface) conversational configs. Reach for this when the user wants expressive TTS audio from text or wants to inspect an EVI voice-agent configuration.

## Tooling
All commands go through `bin/hume-ai.py`. REST auth uses the `X-HUME-API-KEY` header (not Bearer); the CLI wires it through the credential surrogate.

```bash
bin/hume-ai.py auth
# {"ok": true, "configs": 3} on success

bin/hume-ai.py configs
# list EVI configs (id, name)

# Ideogram

## Purpose
Generate images with Ideogram's v3 API: the strongest option in the catalog for text-in-image rendering (thumbnails and carousels with real words), plus Magic Fill editing and style remix, with upscaling and image description on the same key. Use when Michael needs images that contain legible text.

## Tooling
All commands go through `bin/ideogram.py` (multipart form posts):

```bash
bin/ideogram.py auth                                                      # verify the API key (free balance read)
bin/ideogram.py balance                                                   # read billing balance (free)
bin/ideogram.py generate --prompt "retro poster that says SUMMER" --json '{"aspect_ratio": "16x9"}'
bin/ideogram.py edit --prompt "replace the sign with OPEN" --image ./sign.png     # Magic Fill edit
bin/ideogram.py remix --prompt "same scene, watercolor style" --image ./scene.png # style transfer

# Kit

## Purpose
Read and write the user's Kit (formerly ConvertKit) account: list subscribers, broadcasts, sequences, and tags; create broadcast drafts. Use when the user mentions Kit, ConvertKit, or their newsletter.

## Tooling
All commands go through `bin/kit.py`:

```bash
bin/kit.py auth                                              # verify the API key
bin/kit.py subscribers --limit 25                            # list subscribers
bin/kit.py broadcasts --limit 25                             # list broadcasts
bin/kit.py broadcast-create --subject "Hi" --content "..."   # create a broadcast draft
bin/kit.py broadcast-create --subject "Hi" --content "..." --send  # send to the list (confirm first)

# Kling

## Purpose
Generate top-tier video with Kling's official open platform: text-to-video, image-to-video, clip extension, and lip-sync, plus Kolors image generation and talking-avatar endpoints on the same platform. Use when Michael wants the highest-quality AI video clips. Kling is also reachable through fal.ai with simpler auth (trade-off: fal's markup).

## Tooling
All commands go through `bin/kling.py`:

```bash
bin/kling.py auth                                                         # mint a JWT and verify it is accepted (free)
bin/kling.py text2video --prompt "a samurai in neon rain" --json '{"duration": "10"}'
bin/kling.py image2video --image-url https://.../frame.png --prompt "slow zoom out"
bin/kling.py status --task-id <task_id>                                   # poll until succeed/failed
bin/kling.py extend --task-id <task_id> --json '{"prompt": "continue forward"}'   # extend a finished clip

# Langfuse

## Purpose
Read and write the user's Langfuse LLM observability data: browse traces and observations, list prompts and datasets, score traces, and add dataset items. Use when the user mentions Langfuse or LLM tracing and evaluation.

## Tooling
All commands go through `bin/langfuse.py`. Every command takes an optional `--host` (default `https://cloud.langfuse.com`; use `https://us.cloud.langfuse.com` for US-hosted projects or your self-hosted URL):

```bash
bin/langfuse.py auth                                            # verify the credential
bin/langfuse.py traces                                          # list traces
bin/langfuse.py traces --session-id abc123                      # traces for one session
bin/langfuse.py observations                                    # list observations
bin/langfuse.py prompts                                         # list prompts

# Leaf Agriculture

## Purpose
Read and manage farm data through Leaf Agriculture, a unified farm-data API that aggregates the partner-gated OEM platforms under self-serve access: John Deere, CNH Industrial (Case IH/New Holland), Climate FieldView, Trimble, Raven and AgLeader. The primitives it exposes (fields, boundaries, machine operation files for planting/harvest/application/tillage, plus as-applied irrigation) are exactly what a farmer-first fintech and supply-chain digitization product consumes. This is the practical route to partner-gated OEM data without a partnership agreement: individual provider connections need that grower's OAuth consent, which is the normal data-access model rather than a partnership gate.

## Tooling
All commands go through `bin/leaf-agriculture.py`. Every command takes `--user-id` (the Leaf user id from the Leaf dashboard):

```bash
bin/leaf-agriculture.py auth --user-id USER_ID          # verify the API key
bin/leaf-agriculture.py fields --user-id USER_ID        # list fields
bin/leaf-agriculture.py field-get --user-id USER_ID \
    --field-id FIELD_ID                                 # one field
bin/leaf-agriculture.py field-create --user-id USER_ID \

# Lemon Squeezy

## Purpose
Read the user's Lemon Squeezy store: list orders, subscriptions, customers, and products. Create checkout links on confirmation. Use when the user mentions Lemon Squeezy or their digital-product revenue.

## Tooling
All commands go through `bin/lemon-squeezy.py`:

```bash
bin/lemon-squeezy.py auth                                      # verify the API key
bin/lemon-squeezy.py orders --limit 25                         # list orders
bin/lemon-squeezy.py subscriptions --limit 25                  # list subscriptions
bin/lemon-squeezy.py customers --limit 25                     # list customers
bin/lemon-squeezy.py products --limit 25                      # list products

# Letta

## Purpose
Use Letta's agent-shaped memory: list the user's agents (memory lives on a per-user "memory agent"), read core-memory blocks (persona, preferences), list or add long-term archival passages, create standalone memory blocks, and message an agent so it records or updates memory itself. Use when the user mentions Letta or wants agent-held persistent memory.

## Tooling
All commands go through `bin/letta.py`:

```bash
bin/letta.py auth                                            # verify the API key
bin/letta.py agents --limit 10                              # list agents
bin/letta.py core-memory --agent ag_abc123                  # read core-memory blocks
bin/letta.py archival-memory --agent ag_abc123 --limit 20   # list archival passages
bin/letta.py archival-memory --agent ag_abc123 --text "Michael prefers async updates"  # add a passage

# Linear

## Purpose
Work with the user's Linear workspace over GraphQL: view your assigned issues and create new issues. Use when the user mentions Linear or wants an issue created or checked.

## Tooling
All commands go through `bin/linear.py`:

```bash
bin/linear.py auth                                            # verify the connection (viewer query)
bin/linear.py issues                                          # your assigned issues (title, state, team)
bin/linear.py create --team-id TEAM_UUID --title "T" \
    --description "details"                                   # create an issue
```

# Lob

## Purpose
Send physical mail through Lob's Print and Mail API: verify US addresses; create postcards and letters that get printed and mailed; list what was sent; cancel a piece while it is still before production. Reach for this when the user wants a real letter or postcard in the mail rather than an email.

## Tooling
All commands go through `bin/lob.py`:

```bash
bin/lob.py auth                                   # verify the API key
bin/lob.py verify-address --file address.json     # verify/correct a US address (no mail sent)
bin/lob.py send-postcard --file postcard.json \
    --confirm "mail postcard to Jane Doe at 123 Main St"   # send a postcard (test key: simulated)
bin/lob.py send-letter --file letter.json \

# Lodestone

## Purpose
Lodestone is a hosted MCP server that puts several services behind one per-user key. Muse should reach for it when a task needs the user's own Meta Ads account, Instagram account insights, Google Analytics 4 reports, email, a Telegram bot, a Typefully queue, or AI image and video generation.

The connector uses the `muse-directory` connection origin, which exposes 39 tools: 24 read-only and 15 that create, change, spend, or send. Each service beyond the key (Google Analytics, Meta Ads, Typefully, and so on) is connected by the user in their Lodestone dashboard; a tool for an unconnected service replies with the dashboard link instead of failing silently.

[Credential-related source omitted]

Disclosure: the contributor built and operates Lodestone.

## Tooling
All commands go through `bin/lodestone.py` (Python standard library only).

# Loops

## Purpose
Manage Loops email contacts and trigger sends: look up a contact by email, keep contacts current, fire custom events for automations, and send transactional emails from a template. Use when the user mentions Loops or their email contacts.

## Tooling
All commands go through `bin/loops.py`:

```bash
bin/loops.py auth                                              # verify the API key
bin/loops.py find --email "them@example.com"                   # look up a contact
bin/loops.py create --email "them@example.com" --field firstName=Ada   # add a contact
bin/loops.py upsert --email "them@example.com" --field plan=pro        # create or update
bin/loops.py event --email "them@example.com" --name "Signed Up"       # fire an event

# Luma (Dream Machine API)

## Purpose
Generate short-form video with Luma's Dream Machine API: text-to-video and image-to-video, plus generation cancel and image upload for reference frames. A strong default for short clips in the catalog. Confirm exact model IDs in docs.lumalabs.ai before use; the API surface skews toward Dream Machine generation.

## Tooling
All commands go through `bin/luma.py`:

```bash
bin/luma.py auth                                                          # verify the API key (free)
bin/luma.py generate --prompt "waves crashing at golden hour"             # submit a generation
bin/luma.py generate --prompt "slow push in" --image-url https://.../frame.png   # image-to-video
bin/luma.py generate --prompt "..." --model ray2 --json '{"aspect_ratio": "16:9"}'
bin/luma.py status --id <generation_id>                                   # poll (no faster than every 5s)

# Market Evidence Check

## Purpose
Read-only pre-execution evidence for a stated OKX instrument, side, and hypothetical USDT notional. It reads a public OKX order-book snapshot and returns spread, estimated price impact, estimated one-way cost against a declared bps budget, quote age, and displayed-depth checks. Use when the user wants to check market cost/freshness before deciding anything themselves.

GO only means the declared checks passed on that public snapshot. It is not a buy/sell recommendation, trading signal, profit prediction, fill guarantee, or permission to trade.

## Tooling
All commands go through `bin/market_evidence_check.py` (Python standard library only):

```bash
bin/market_evidence_check.py health
bin/market_evidence_check.py check --instrument BTC-USDT --side buy --notional-usdt 1000 --max-cost-bps 30
```

# Mastodon

## Purpose
Read and write the user's Mastodon account: verify the connection, list own toots, list followers, publish toots (with native scheduling via `scheduled_at`), upload media for toots. Use when the user mentions Mastodon or the fediverse.

## Tooling
All commands go through `bin/mastodon.py`:

```bash
bin/mastodon.py verify --host https://mastodon.social                                  # verify the token (own profile)
bin/mastodon.py my-posts --host https://mastodon.social --limit 20                     # recent toots
bin/mastodon.py followers --host https://mastodon.social --limit 20                    # own followers
bin/mastodon.py post --host https://mastodon.social --text "hello"                     # confirm first
bin/mastodon.py post --host https://mastodon.social --text "later" --scheduled-at "2026-09-17T09:00:00Z" --visibility unlisted

# mem0

## Purpose
Manage the user's mem0 memory layer: store memories extracted from messages, run semantic search over them, and handle the full lifecycle (list, read, delete) scoped by user, agent, or app. Use when the user mentions mem0, a persistent memory layer, or asks to remember or recall facts.

## Tooling
All commands go through `bin/mem0.py`. Add and search are **async**: they return an `event_id`, which you poll with `status`.

```bash
bin/mem0.py auth                                                          # verify the API key
bin/mem0.py add --user-id alice --message "Michael prefers morning standups"  # store a memory (async)
bin/mem0.py status --event-id <event_id>                                  # poll an add/search event
bin/mem0.py search --user-id alice --query "meeting preferences"          # semantic search (async)
bin/mem0.py list --user-id alice                                          # list memories for a user

# Mercury

## Purpose
Read-only access to the user's Mercury banking: list bank accounts and view recent transactions per account. Use when the user mentions Mercury, asks about a Mercury balance, or wants Mercury transactions. This connector cannot move money or change anything.

## Tooling
All commands go through `bin/mercury.py`:

```bash
bin/mercury.py auth                                # verify the connection
bin/mercury.py accounts                            # list bank accounts
bin/mercury.py transactions --account A --limit 20 # recent transactions for account A
```

# Mistral AI

## Purpose
Call Mistral's La Plateforme API: run chat completions on Mistral models, create text embeddings, extract text and markdown from documents and images with the dedicated OCR endpoint, and list the models available to the API key. Reach for this when the user wants a Mistral model for generation, embeddings, or document OCR.

## Install
Copy, paste to your Muse:

```
Install this connector: https://raw.githubusercontent.com/bluman1/muse-connectors/main/connectors/mistral/SKILL.md
You are Muse. Fetch the URL above: it is a connector skill's SKILL.md.
1. Read its `## Files` manifest and download every listed file from the same directory (replace SKILL.md in the URL with each relative path).
2. Save them under ~/workspace/skills/mistral/, preserving paths. Compile any bin/*.py with python3 -m py_compile.
3. Follow the skill's `## Auth` section: connect my account via your secure credential flow (credentials.request_api_access) for the provider id it names.

# Monday

## Purpose
Read and write the user's monday.com workspace: list boards, read items on a board, create items. Use when the user mentions monday.com or a Monday board.

## Tooling
All commands go through `bin/monday.py`:

```bash
bin/monday.py auth                                      # verify the token
bin/monday.py boards --limit 25                         # list boards
bin/monday.py items --board BOARD_ID --limit 25          # list items on a board
bin/monday.py create-item --board BOARD_ID --name "Task"  # create an item
```

# Moonraker

## Purpose
Control a Klipper-based 3D printer through the Moonraker API server (the backend behind Mainsail, Fluidd and RatOS): read server and print status, list and upload gcode files, start/pause/resume/cancel prints, trigger the emergency stop, toggle smart-plug devices, and (gated) run raw G-code. Use when the user mentions Moonraker, Klipper, Mainsail, or Fluidd.

## Tooling
All commands go through `bin/moonraker.py`. `--host` points at Moonraker (default `$MOONRAKER_HOST` or `http://localhost:7125`); `--insecure` skips TLS verification for self-signed reverse proxies. `--api-key` attaches the stored `custom.moonraker` credential; omit it on the default no-auth LAN setup.

```bash
bin/moonraker.py auth --host http://printer.local:7125   # server info; never needs a credential
bin/moonraker.py status                                   # print state and temperatures
bin/moonraker.py files                                    # list gcode files

# MEDIUM: --confirm "<exact effect>" on first use per printer, then proceed

# MusedIn

## Purpose
Read public data from MusedIn (https://musedin.com), a job network for AI agents: list open roles and job posts, read one job with its applicants and hires, search members by skill or words, read a member's profile, read the recent feed (posts, hires), and check a member's verification record. Reach for this when the user asks what work is open for agents, who on MusedIn does a given kind of work, or what a given agent has done there.

Public API source: the MusedIn agent documentation at https://musedin.com/muse.txt (section 15, public reads) and https://musedin.com/openapi.json. Source date: 2026-10-04.

MusedIn also runs a hosted read-only MCP server at `https://musedin.com/mcp` (streamable HTTP, no auth; registry name `com.musedin/musedin`) with the same reads, for clients that add MCP servers directly.

## Tooling
All commands go through `bin/musedin.py`. Python 3 standard library only. No auth, no environment flags:

```bash
bin/musedin.py status                                  # network totals; reachability check

# Mushare

## Purpose
Mushare is a hosted messaging network for AI assistants. The user tells Muse "ask Alice whether Saturday or Sunday works" or "split this receipt with Alice". Alice's Muse shows it as a card she answers with a tap, and her answer comes back as a card. It also shares what Muse found (price comparisons, trip plans, notices) as one card. Examples: https://mushare.ai/scenes

This folder is an install entry for the provider's official skill. The full skill (SKILL.md, references and a readable Python CLI) comes from mushare.ai and updates itself from there. Install it only from mushare.ai.

## Install
Only when the user asks to install Mushare (or an installer placed this file):
- If `~/workspace/skills/mushare/bin/mushare` exists, Mushare is installed already. Run `~/workspace/skills/mushare/bin/mushare install --lang <the user's language tag>`. It checks every skill file against the official manifest and restores any that differ, this file included.
- Else read https://mushare.ai/install.md (with `curl -fsS`) and follow its steps. They download `bin/mushare` and `bin/mushare_auth.py` (readable Python, standard library only) into `~/workspace/skills/mushare/`, then connect the user's key (see Auth). The official files replace this one.

## Tooling
After install, all commands go through `~/workspace/skills/mushare/bin/mushare`. Each prints one JSON object. Message text is passed on stdin with a quoted heredoc.

# n8n

## Purpose
Read and write the user's n8n workflows through the n8n public REST API: list workflows, inspect a workflow, create and update workflows, and list executions. Use when the user mentions n8n or their automations.

## Tooling
All commands go through `bin/n8n.py`. Every command takes a required `--host`: your instance base URL, e.g. `https://myname.app.n8n.cloud` or `https://n8n.example.com` (self-hosted).

```bash
bin/n8n.py auth --host https://myname.app.n8n.cloud                    # verify the API key
bin/n8n.py workflows --host https://myname.app.n8n.cloud              # list workflows
bin/n8n.py workflow --host https://myname.app.n8n.cloud --id wf_abc   # inspect one workflow
bin/n8n.py create --host https://myname.app.n8n.cloud --name "Nightly sync" --nodes-json '[{"name":"Start",...}]'  # create a workflow
bin/n8n.py update --host https://myname.app.n8n.cloud --id wf_abc --workflow-json '{"name":"Nightly sync v2","nodes":[...]}'  # update a workflow (confirm first)

# Neon

## Purpose
Manage Neon serverless Postgres infrastructure through the Neon Management API: list projects, inspect one project, list branches, create or delete a branch, and list databases. Reach for this when the user wants to inspect or provision database infrastructure. SQL queries run over the Postgres wire protocol, so this connector manages infrastructure only; it does not run queries.

## Tooling
All commands go through `bin/neon.py`:

```bash
bin/neon.py auth                                          # verify the API key
bin/neon.py projects                                      # list projects
bin/neon.py project-get --project-id PROJ_ID              # one project
bin/neon.py branches --project-id PROJ_ID                 # list branches
bin/neon.py branch-create --project-id PROJ_ID --name dev \

# Netlify

## Purpose
Read-only visibility into the user's Netlify account: list sites and inspect recent deploys for a site. Use when the user asks about their Netlify sites or whether a deploy succeeded.

## Tooling
All commands go through `bin/netlify.py`:

```bash
bin/netlify.py sites                    # sites (name, url, deploy state)
bin/netlify.py deploys --site SITE_ID   # recent deploys (state, created)
```

Find a site's ID in Site settings → General → Site details → API ID.

# NewsAPI

## Purpose
Read-only news: top headlines by country and full-text search across news articles. Use when the user asks for news, headlines, or mentions NewsAPI.

## Tooling
All commands go through `bin/newsapi.py`:

```bash
bin/newsapi.py headlines --country us --limit 10      # top headlines
bin/newsapi.py search --query "spacex" --limit 10      # search all news
```

## Auth

# Notion

## Purpose
Work with the user's Notion workspace: search pages and databases, read page properties, query databases, and write: create pages, append blocks to a page, and update page properties. Use when the user mentions Notion or wants something looked up or recorded in their Notion.

## Tooling
All commands go through `bin/notion.py`:

```bash
bin/notion.py auth                              # verify the connection (search with page_size 1)
bin/notion.py search --query "roadmap"           # search pages and databases
bin/notion.py page --id PAGE_ID                  # read a page's properties
bin/notion.py query-db --id DATABASE_ID          # query a database (first 20 rows)

# OctoPrint

## Purpose
Control an OctoPrint 3D printer over its local REST API: read printer state and temperatures, monitor print progress, start/pause/cancel/restart jobs, upload and select gcode files, set hotend and bed temperatures, jog or home axes, and (gated) run raw G-code. Use when the user mentions their OctoPrint instance or a printer it drives.

## Tooling
All commands go through `bin/octoprint.py`. `--host` points at the OctoPrint instance (default `$OCTOPRINT_HOST` or `http://localhost:5000`); `--insecure` skips TLS verification for self-signed reverse proxies.

```bash
bin/octoprint.py auth --host http://octopi.local:5000     # verify the API key
bin/octoprint.py version                                   # server version
bin/octoprint.py status                                    # printer state, hotend and bed temps
bin/octoprint.py job                                       # current print progress
bin/octoprint.py files                                     # list gcode files on the printer

# OpenAI

## Purpose
Check that the user's OpenAI API key works and list the models available to it (id and owner). Read-only by design: this skill never spends credits; it ships no completion, image, or other billable calls.

## Tooling
All commands go through `bin/openai.py`:

```bash
bin/openai.py models    # list models available to this key (id, owned_by), truncated to 40
```

## Auth
- Provider id: `openai` (credential is collected as `custom.openai`)

# OpenRouter

## Purpose
Read-only access to OpenRouter: browse the full model catalog with per-token pricing, and check the connected key's label, usage, and limit. Use when the user asks which models are available, what a model costs, or how much of their OpenRouter key they've spent.

## Tooling
All commands go through `bin/openrouter.py`:

```bash
bin/openrouter.py models   # model catalog (id, name, prompt price)
bin/openrouter.py key      # your key's label, usage, limit
```

## Auth