Skip to main content
Glama
649,985 tools. Updated 2026-10-08 15:16

"How to Run a Python Script" matching MCP tools:

  • Run arbitrary Blender Python (bpy) against a base revision and commit the result as a new immutable revision. Policy-gated: an owner must enable scripting on the deployment first. Runs in a credential-free, network-restricted throwaway container; the runner loads the scene before your script and commits it after. Assign a JSON-serializable value to a variable named `result` to get it back in job_get result.scriptResult with full finite JSON retained in an immutable report up to 8 MiB. Use job_report section=report for complete stored bytes; non-JSON or oversized results are explicitly unavailable. The result variable is not predeclared: no assignment records hasResult=false, while result=None records hasResult=true with JSON null. print() output returns as result.scriptStdoutTail — both are returned in the job_get/job_wait text, so use them for introspection instead of encoding findings into object names. A script that raises commits NOTHING: the revision is only written after the whole script succeeds, so failures leave the base revision untouched. The runner evaluates the depsgraph before your first statement, so world transforms of pre-existing objects are correct on entry; objects your script CREATES keep an identity matrix_world until you call bpy.context.view_layer.update(), so measure world positions only after that call — otherwise obj.matrix_world reads zeros and any floor, bounds or framing number you derive from it is silently wrong. The environment is FIXED (Blender 5.2 LTS) — verify identifiers with docs_bpy_lookup (free, instant) instead of a probe job. Call docs_operations FIRST: the validated DSL already covers 298 operations including booleans, lathe, loft, UV unwrap, modifiers, materials, lights, cameras and render settings, and scene_apply is cheaper and safer for all of them. Reach for scripting only for shader node graphs, novel parametric generators, and computation.
    Connector
    Destructive
    API key
  • Mint a one-time uploader script for a private Storage blob (any file type). Storage is the org's binary store: bytes go to the Railway bucket, metadata to ``drive_objects``. Objects stay private until a human seat calls ``storage_publish`` (agent seats must ``request_gated_approval(gate=publish)``). Document MIME types (Markdown, HTML, plain text, diagram JSON/YAML) are stored as blobs; versioned edit / ``/s/`` publish still use ``file_upload_request``. Pass ``work_id`` and/or ``project_id`` to attach after ingest (``kind=artifact``; transcripts stay on shared files). Pass ``parent_id`` to place the file in a folder. Batch uploads are multiple grants (one file each) — console multi-select uses sequential ingest, not a multi-file grant. Returns ``upload_url``, ``upload_token``, ``max_bytes``, and a self-deleting Python ``script``. Token is single-use and expires in ~10 min. ``drive_upload_request`` is a deprecated alias of this tool.
    ConnectorNo auth
  • Validates a Python automation script that runs OUTSIDE the game, on three axes: Python syntax (using the real interpreter), Minecraft commands embedded in the script (against the official command index), and the shape of the /connect WebSocket message envelope. For behavior pack scripts use validate_script instead — Python does not run inside a pack. The embedded command check is the most valuable one: a command written from memory can look syntactically fine and still do nothing in the game. Only strings starting with / are treated as commands. If syntax could not be checked, syntaxChecked is false in the result; ok:true alone does not mean the syntax is valid.
    ConnectorNo auth
  • Get ONE test case's result inside a run: status code, timing, the response body and headers, every assertion outcome, extracted variables and any script output. This is the read to make when a run failed and you need to know why. The id comes from get_test_run's results[].id, not from get_test_results (run ids). Requires project context.
    ConnectorAPI key
  • Run a code snippet inside a sandbox and return {exit_code, stdout, stderr, timed_out, truncated, duration_ms}. `language`: python (Python 3.12), node (Node.js 22) or bash. Install packages first with exec_command (`pip install …` / `npm i …`). The code is passed to the interpreter on stdin, so it cannot read stdin itself. `timeout` seconds (default 30, max 55 per call). LONGER JOBS: set `background: true` — returns a `task_id` immediately (timeout then defaults to the sandbox's remaining lifetime); poll get_task with the returned offsets to read new output and the exit code, kill_task to stop it. The sandbox keeps billing while a task runs and is not idle-deleted. Output is capped at 1 MiB per stream for synchronous calls. Files and installed state persist between calls in the same sandbox. Requires: token + live sandbox_id. Typical: timed_out after 55 s → repeat with background: true.
    ConnectorNo auth
  • For books LARGER than 500 transaction rows. Returns a complete, runnable Python script that scores the book into A/B/C/D tiers with survival modelling (BG/NBD), spend modelling (Gamma-Gamma), tier migration, a money layer and plain-language decision cards. Run it in your code sandbox against the user's transaction file. The rows never pass through you as tokens, so a 10,000-row book costs the same to run as a 600-row one. Needs numpy. Prints ranked decisions and headline figures; writes the full per-customer ledger to customer_tiering_result.json beside the input file. No customer data reaches this server on this path. SAVE AND RUN THE RETURNED SCRIPT VERBATIM — every block of it is required for the computation. Do not retype it from memory, shorten it, reformat it, split it up, or reimplement the maths with pandas/sklearn; only the PATH / AS_OF / CURRENCY / OUT / OVERRIDES / CONTACTS lines at the bottom may be edited. The script cleans customer identities itself before scoring — merging capitalisation and spelling variants by rule, printing what it merged, and listing the similar-but-unproven groups for you to rule on via OVERRIDES — so do not pre-clean the file or edit those rules. Optionally takes contacts_path, a log of rep calls or visits (customer_id + date only). It is not required and the book scores fine without it, but it is valuable: with it the money layer MEASURES what a contact is worth per tier from touched-vs-untouched tier transitions instead of assuming a flat rate, so ask for it whenever the user mentions a CRM, a call log or a visit register.
    ConnectorOAuth

Matching MCP Servers

Matching MCP Connectors

  • Run Python code from natural language prompts, with optional PyPI package install.

  • 生成式AI备案、AI生成内容标识、深度合成、算法备案:条文级问答 + 按条号取法规原文 + 应办清单(中文)

  • Search the RoxyAPI knowledge base and get back ranked documentation snippets, each with a source URL. It covers API endpoints with their request and response fields, SDK usage for TypeScript, Python, PHP, C#, and Go, the WordPress plugin, authentication and API keys, UI components, and step by step integration guides. Call this first whenever you need to integrate RoxyAPI into an app: to find which endpoint or SDK method to use, what parameters a call takes, how to authenticate, or how to wire a feature end to end. Pass the user question verbatim as `query`. If the first results miss, rephrase once and retry.
    ConnectorNo auth
  • **Executes the task on the real websites** and returns the result. Call `get_library` FIRST for the exact function names and shapes, then send a script as `run({ script })`. THE SCRIPT is a plain async JavaScript body, not a wrapping function. `bowmark` is a ready global: `await bowmark.<capability>.<fn>(...)`, or one site via `await bowmark.providers.<provider>.<fn>(...)`. `return` what you want back; `log(...)` for progress. Built-ins plus `URL`/`URLSearchParams` exist; `fetch`, `import`, `setTimeout` and a filesystem do not — `bowmark` is the only I/O. MIND THE CLOCK. Your client times a tool call out at around 55 seconds, and one capability call already spends 30-55 seconds, so default to ONE per script. Need several? Run them together in `Promise.allSettled` (a dropped leg still comes back as `partial`), never one after another, and never `await` inside a `for` loop. Keep the result under ~25,000 characters. CHECK `status` BEFORE `ok` — `ok` | `error` | `partial` | `needs_user` | `running`: • `running`: it is still going. Call `run({ runId })` to wait for the SAME run; never resend the script. • `partial`: `result` is real but narrower than asked; `incomplete` names what did not answer. Tell your user — never call it complete. `incomplete.failures[].fixable: true` means your argument was wrong: fix it and rerun. • `needs_user`: a site needs your user signed in. It is not a failure: give them `meta.handoff.url`, say which sites, and wait. When they are done, send the SAME script unchanged. • `error`: there is no result; `error` says why. Saving files, one exit IP, saved secrets, `warnings`, `emptyHanded`, and the billed `browser_agent`/`delegate` fallbacks: `get_library({ query: "run guide" })`.
    Connector
    Destructive
    No auth
  • Get the Designesy WCAG 2.2 AA accessibility verification framework: 11 conformance checks (a01-a11) plus a ready-to-run Playwright + axe-core 4.13.0 script template targeting your URL. Use this to audit a site for accessibility violations. When NOT to use: for a full design-contract score (not just a11y), use designesy_score. Does NOT run the scan: axe-core needs a real browser DOM. Returns the 11 checks + a Playwright script you execute locally (npm i -D @axe-core/playwright). The score comes from your local run, not from this tool. Returns JSON: { checks[{id (a01-a11), name, status: "PENDING_EXECUTION"}], playwright_script, install_command, run_command }. Pass config (JSON string) to customize axe.configure(), for example with branding overrides or rule disables. Omit for standard WCAG 2.2 AA.
    ConnectorNo auth
  • For pipelines LARGER than 500 lead rows. Returns a complete, runnable Python script that loads the lead export in your sandbox and scores it locally (conversion probabilities, money layer, Shapley attribution, CALL / NURTURE / VERIFY queue). Makes no network calls — same shape as Customer Tiering — so Copilot Studio works even when outbound POST is blocked. The rows never pass through you as tokens. Needs numpy. Prints ranked decisions and headline figures; writes the full per-lead ledger to lead_pipeline_result.json. SAVE AND RUN THE RETURNED SCRIPT VERBATIM — do not retype, shorten, reformat, or reimplement it; only PATH / TOUCHES / STAGE_HISTORY / AS_OF / CURRENCY / OUT may be edited. Optionally takes touches_path and stage_history_path for engagement and funnel history.
    ConnectorOAuth
  • Run a read-only script against the connected Foundry world. `code` is the body of an async function: call foundry.<domain>.<method>({ ... }) (see docs), use await, console.log, and return the value you want back (JSON, size-limited). Only read methods are bound; writes are not available here — use execute. Every call counts against the per-script limits shown in the docs index (calls, wall time, CPU time, result size); an oversized call result arrives as { __truncated: true, bytes, limit, preview }.
    ConnectorAPI key
  • Use this when the user shares a link to a public Instagram Reel, YouTube Short or TikTok and asks why it went viral, how strong its hook is, or wants a script based on it. Analyzes why a short video went viral: the opening hook and its score, why it went viral, and a ready-to-shoot script adapted to the user, plus a caption and hashtags. Uses one analysis from the account's monthly plan (repeating the same URL does not). Returns the result if it is ready within a few seconds, otherwise a job_id - then call get_analysis with it after 30-60 seconds. Do not use without a video link, or to reopen a finished analysis (get_analysis).
    ConnectorOAuth
  • Use this when a local script needs a stored login's values. Let a local script read a credential: returns a single-use URL, valid for about 60 seconds, whose fragment is a token; a POST of `{ token }` to the URL without its fragment answers the values as JSON. `name` resolves to your own personal credential, else the company-wide one shared with you; when neither exists it fails `not_found`, and you send the person a `credential_request` link to add their own. Hand the URL to the script; never fetch it yourself. Every use is recorded. Error codes: invalid_input, forbidden, not_found, database_failure, conflict, storage_failure, maintenance, INVALID_ARGUMENTS, INSUFFICIENT_SCOPE, ORGANIZATION_MEMBERSHIP_REQUIRED, SESSION_EXPIRED, activity_unavailable.
    ConnectorOAuth
  • Use when the user asks to send, save or import a script they attached or pasted in this chat into their own blablabla account. The script waits in their blablabla inbox until they open the app and import it, the same way as a file shared from Files. Pass attached files exactly as provided (one script file, or up to 20 photos of its pages in page order). Use text only for a script the user pasted into the chat themselves, exactly as written, without summarizing, fixing or reformatting it. Never put your own transcription or description of an attached file or photo into text; if an attachment did not arrive, ask the user to attach it again. blablabla reads the script itself in the app. This app cannot read, search or list the user's blablabla scripts, and nothing about the script comes back here; the reply only confirms delivery. Never use it for files that are not the user's own script, and never invent a file or text.
    ConnectorNo auth
  • Read a page and write a schema.org JSON-LD block for it, then validate that block against the same checks a validator would run. The markup is model-written from the page's own content and should be reviewed before it is published. Returns the block ready to paste into a <script type="application/ld+json"> tag. Returns { ok, report: { detectedType, jsonLd, jsonLdString, validation: { findings[], passed }, model } }. Limit: 10 runs per hour per IP. Allow up to 75s for a response. Free, no account, no API key. Pass `url` to start a run. A slow run answers with `{ status: "pending", runId }` instead of a result: call this same tool again with just that `runId` to collect it, as many times as it takes. Collecting costs no rate-limit slot.
    ConnectorNo auth
  • Requires an API key with the write scope or higher. Commit, at the START of a run, to the criteria by which THAT RUN will be judged when it closes — before you can see how it turns out. This is how a run stops grading itself: once declared, a success ping whose body does not satisfy every declared criterion is recorded as a FAILED run with cause 'assertion', regardless of the exit code or what the ping claims. Call this right after your run's /start ping, before doing any work — see the assertions argument for the full, immutable contract, and get_ping_instructions' expectations_how_to for a worked example.
    ConnectorOAuth
  • Heuristic estimate (NOT a real per-model BPE tokenizer) of how many tokens a piece of text will become, ported from GO AI's browser-side token counter. Blends a chars/4 and words/0.75 baseline with surcharges for punctuation, digits and non-Latin script; typically within ±10-15% for ordinary English prose and ±15-25% when non-Latin script is detected -- code and heavily punctuated text tend to tokenize denser than this suggests. Also reports whether the text fits a set of context windows (default: 8K/128K/200K/1M/2M tokens, or pass your own) and, if you supply per-million-token prices, an estimated USD cost. Use a provider's own tokenizer for exact billing figures.
    ConnectorNo auth
  • Runs a shell command on the user's Mac and returns its output. Always active. Disabled when LMCP is in read-only mode. Dangerous commands (sudo, recursive deletes of system/home paths, disk formatting, shutdown/reboot, piping a downloaded script into a shell, fork bombs, daemon control) are refused. Destructive: it previews the command first — pass confirm:true to actually run it. Output and runtime are capped.
    Connector
    Destructive
    OAuth
  • Starts writing the script: chapters, pages, panels, dialogue and captions. Returns immediately; it takes about 2 to 3 minutes, then aetherwave_comic_status shows the panels. Charged on actual use when it finishes (a 12-page script cost 40 credits). Approve character references first. Re-writing a script DELETES every page and panel already made, including drawn panels, so a project that already has panels needs replaceExisting: true.
    Connector
    Destructive
    No auth
  • Find which documentation SETS exist whose NAME matches a substring (e.g. "python" → Python 3.x, "react" → React). Returns doc SETS, NOT their content — this does NOT look up a function/method/API name. To search inside a doc for an entry like "Array.map" or "fetch", use search_index (slug + query).
    ConnectorNo auth