Skip to main content
Glama
619,891 tools. Updated 2026-09-28 19:29

"Artifact Hub" matching MCP tools:

  • Get a swap quote from the SODAX solver. tokenSrc/tokenDst MUST be hub-chain (Sonic, chainId 146) asset addresses — look them up with sodax_get_solver_oracle (chainId='146'). Working example: tokenSrc='0xeb0393893b5bf98a50073d6740738b08e575058b' (BTC_BTC_ASSET) → tokenDst='0xaeafa26e43f46cd83efe89b1e57c858eb5685a24' (ETH_ASSET), amount='99800', quoteType='exact_input' returns a quoted_amount. exact_input quotes the destination amount you'd receive; exact_output quotes the source amount you'd need. There are two distinct HTTP-400 failures, both naming the two addresses: (1) 'not compatible with the quote service' = an address isn't a recognized hub asset (a spoke-chain or otherwise non-chainId-146 address was passed) → use a chainId-146 address from sodax_get_solver_oracle, and for a reliable pick prefer a canonical bridged *_ASSET hub token or major stablecoin (chainId 146 alone doesn't guarantee a route). (2) 'No path was found between X and Y' = both tokens are valid hub assets but the solver couldn't route this pair for this amount → routing is pair/amount/liquidity-dependent, so retry with a smaller amount or a more liquid counterparty (a canonical bridged *_ASSET token, or a major stablecoin like SONIC_USDC_ASSET). Many wrapped/derivative entries (e.g. WBTC, waLocBTC, SONIC_SODA_ASSET) are oracle-priced but frequently have no route — prefer canonical bridged *_ASSET hub tokens.
    ConnectorNo auth
  • Check the build status of an EXISTING artifact (from artifact-create). Read-only. Generation is asynchronous, so this is how you find out it finished. Call it with { sessionId, wait: true } and it WAITS for you: the call returns as soon as status is 'ready' or 'failed', or after about 45 seconds still 'generating'. Then, you can call it again. This tool is meant to be called right after artifact-create, before replying to the user, and keep getting called until status is no longer 'generating'. ONLY when you want an instant snapshot, this tool can be called without wait (or false); the idea is to never spin on wait: false. Requires sessionId — the id returned by artifact-create (or the last path segment of an artifact URL like https://app.agentgrid.io/artifacts/<sessionId> or https://dev.animaapp.com/chat/<sessionId>). **Returns:** { success, sessionId, status: 'generating' | 'ready' | 'failed', progress (0–100, while generating), name, artifactUrl (generating/ready only), playgroundUrl (app and knowledge artifacts only, generating/ready only), previewUrl (app, knowledge and markdown artifacts only, generating/ready only), error (when failed), nextStep (when a wait returned still generating) }
    ConnectorOAuth
  • Step 1 of the zip import flow for artifact-create: for imports with binaries or over roughly 100 KB of source; small text-only projects pass files inline. **Flow:** 1. Call this tool: returns zipUploadId and presigned uploadUrl. 2. HTTP PUT the project zip to uploadUrl. 3. Call artifact-create (type import) with zipUploadId within 30 minutes of the last upload; the zip becomes the first commit and zipUploadId is single-use. **Rules:** zip max 50MB; source, config, assets only — no node_modules or build output. Shell/executable files are skipped and reported. uploadUrl is a secret. **Returns:** success, zipUploadId, uploadUrl, uploadUrlExpiresAt, nextSteps.
    ConnectorOAuth
  • Update an existing remote artifact while keeping its address, or rename its display title. For 'replace this report with the new version', supply exactly one of html/files/upload_id AND expected_version from get_site/export. This replaces ALL contents; omitted files are removed. For 'rename this artifact', supply only slug and title: no content version is created. Do not combine a rename-only request with upload fields. Use edit for one text file. A 409 means someone changed the artifact: inspect it before explicitly choosing what to keep; staged bytes remain available.
    Connector
    Destructive
    OAuth
  • Find complete multi-day stopover itineraries between two cities: an outbound leg, 1 to 7 days in an intermediate hub city, then the onward leg, priced as one trip from live Google Flights data (GBP) with a booking link on every leg. One call evaluates dozens of hub cities and date splits. Runs as a background job: returns a jobId immediately; poll get_job_result every few seconds until status is done.
    ConnectorNo auth
  • Create a NEW artifact in Agent Grid; never edits an existing one. Two independent axes, easy to confuse: **type** (below) is where the files come from, and **artifactType** is what the artifact IS. artifactType defaults to app — a live web application that renders and runs at the returned URL as soon as it is ready, which is what every type below produces unless you say otherwise. Pass artifactType markdown for a readable document, or asset for a stored file: neither is a running app, so do not promise a live URL for them. Generation types (p2c/l2c/f2c) run ASYNCHRONOUSLY: this returns IMMEDIATELY with { status: 'generating', sessionId, artifactUrl, previewUrl, playgroundUrl } while the app is still being built. The preview link shows a live loading screen that swaps in the finished app. Most of the time, you need a single call to artifact-status with { sessionId, wait: true }, BEFORE you reply to the user because it blocks until the app is ready or failed, so you report a finished app rather than a promise (if it returns still 'generating', call it again). This artifact-create tool is NOT meant to be called multiple times for the same generation request. While a matching job is active, the same stable request identity may reuse that job for the team instead of creating another. The own-code types (empty/import) return immediately. **Do NOT use for:** editing an existing artifact (artifact-explore + artifact-edit, or the git flow via artifact-get_git_token); rename/visibility (artifact-update_metadata); deploying live (artifact-publish). **type:** Anima GENERATES (async — poll artifact-status): - p2c: text prompt (requires prompt; optional guidelines) - l2c: website (requires url) - f2c: Figma frames (requires fileKey + nodesId + X-Figma-Token header) YOU supply (ready immediately): - empty: empty git repo you push to (requires framework) - import: your code is the first commit; EXACTLY ONE of files (inline text, up to roughly 100 KB) or zipUploadId (binaries or larger) **framework:** only html and react exist. Required for empty; optional for import (detected from package.json) and generation types (default html). **Returns:** generation types (p2c/l2c/f2c) → { success, status: 'generating', sessionId, artifactUrl, playgroundUrl, previewUrl }; poll artifact-status for completion. Own-code types (empty/import) → sessionId, revision, artifactUrl, name, gitRemoteUrl, access, expiresAt, nextSteps (plus fileCount, skippedFiles for import), and a read-write git token in the same response — so do NOT call artifact-get_git_token after creating. playgroundUrl comes only when artifactType is app; previewUrl renders those plus markdown artifacts, while asset artifacts expose only artifactUrl. A markdown inline-files import also returns documentPreview plus documentPreviewTruncated, so the preview card can render the bounded document text without a follow-up read. `revision` is the first commit: pass it straight to artifact-edit as baseRevision if you edit without git. These are ready immediately (no 'generating' status): previewUrl renders the committed files right away for import, and the seed README for empty.
    ConnectorOAuth

Matching MCP Servers

Matching MCP Connectors

  • One place for every AI agent's pages and docs: versioned links to share, search and update.

  • One MCP endpoint over 69 public PPN APIs: search_apis to discover, execute_api to call. Free tier.

  • Inspect the files of an EXISTING artifact: list them, search their text, read them, or review the commit history. Works with no shell, no git and no network access, so prefer it whenever you cannot run git. Pass the sessionId (the last path segment of a .../chat/<sessionId> URL). A canvasDraft field, when authorized, reports an uncommitted Canvas draft. Use action draft to inspect its projection overlay explicitly; ordinary reads remain committed files. Draft access requires write permission. Typical flow to change something: action "search" to find the file, action "read" for the files you will edit, then artifact-edit. Every response includes "revision", the artifact's current commit — pass it back as artifact-edit's baseRevision. Use action "read" with a "revision" to see how a file looked at an earlier commit (this is how you undo something). Assets — images, fonts, media — are readable too: action "read" answers with size, mime and oid under "asset": true whenever a file's bytes are not text, instead of content. That check is on the bytes, so it is the authority: an SVG reads as text, and a file with an unfamiliar extension may still come back as an asset. When a search comes back empty, check "notSearched": "assets" counts binary files a text query can never match, and "excluded" counts files under node_modules, dist or build — re-run with includeExcluded true to search those. A "tree" listing also maps any path artifact-edit cannot change under "unwritable". For generation or build progress use artifact-status instead; this shows the commit log, not build state.
    ConnectorOAuth
  • List the caller's favourites folders (name, entity_type, item_count). Pass entity_type (creo/webmaster/ad/hub/shop) to filter; omit it to list folders across all types. Pass folder (a folder name) to instead return the ITEMS inside that folder: entity ids for creo/webmaster/ad (usable with get_creative / get_webmaster / get_ad), resolved hub profiles (hub + id + label) for hub folders, and domains for shop folders. Use this to confirm what add_to_favorites saved and to read a folder back. FREE — does not consume quota.
    ConnectorOAuth
  • Published supply and demand balance (physical, in tonnes) for one agricultural hub, season by season: production, imports, exports, consumption, initial and final stock, whether the season is still an estimate, and how many months a partial season measures. `hub` accepts only the hubs that have a published balance sheet, which is fewer than the hubs the forecast tools cover; `closedOnly` drops the current season, which is a projection and still moves. The source is a Brazilian government body and is named in the result. This is the physical BALANCE of a season. The price verdict for the same hub is kyrodata_get_hub_summary, and the weather risk behind production is kyrodata_get_climate_reading. Credit class: level (any level tool in a 60-second session = 2 credits; a session is capped at 3).
    ConnectorAPI key
  • Import a fetchable official GPX/FIT/CRSProf URL, official ZIP containing exactly one GPX, uploaded source_file artifact, raw JSON payload, or inline/proxied course_file into a CRSProf artifact. Third-party route hosts such as Wikiloc may return 403 to server fetches; when a URL is blocked, ask the user to download/upload the file through POST /api/artifact-uploads outside MCP and pass the returned source_file artifact ID as source.kind=artifact. For structured answers about a supplied activity, prefer analyze_activity. This is the lower-level artifact-only import; no catalog search, runner profile, or waypoint enrichment is required. For named race planning without a supplied source, search the catalog first.
    ConnectorNo auth
  • Publish an artifact — deploys its committed files (git HEAD; uncommitted edits are not included) to a live public URL. Works for app AND markdown artifacts; an asset artifact cannot be published (tell the user so and share its artifactUrl instead). Publishing makes the content PUBLIC to the world. It is NOT needed for sharing — the artifact is already visible at its artifactUrl to everyone who can reach it, and liveUrl is NOT an editor. Call this only when the user explicitly asked to publish/deploy; otherwise share that URL and offer publishing as a follow-up question. Requires a sessionId from a previously created artifact (via artifact-create). **What goes live:** - app: the running web application. - markdown: one document. liveUrl renders the initial file (README.md if present, else the first .md lexicographically); the raw source is at <liveUrl without the query string>/index.md (Content-Type: text/markdown) — give the user that path when they want the markdown. Other .md files are served raw at their own paths, each with a rendered .html sibling. ```mermaid fences render as diagrams; the .md keeps the fence. accTitle/accDescr label a diagram. **Modes:** - "webapp" (default): Deploys to a live URL; use it for both app and markdown artifacts. Returns { success, liveUrl, subdomain }. - "designSystem": NOT available over MCP — always fails with an enterprise contact link, whatever you pass. Do not offer it as a capability. **Returns:** { success, liveUrl, subdomain }
    Connector
    Destructive
    OAuth
  • Change the files of an EXISTING artifact and commit them, without git or a shell. Never creates a new artifact — the sessionId keeps pointing at the same one, and its playground URL does not change. If a Canvas draft exists, this refuses unless acknowledgeCanvasDraftRevision matches the draft you reviewed and the user explicitly chose to edit committed files. It does not edit, promote or discard the draft. All the changes you pass land as ONE commit: either every operation applies or none does. Read the files first with artifact-explore and pass the revision it returned as baseRevision; if someone else changed the artifact meanwhile the edit is rejected with REVISION_CONFLICT, which lists what changed so you can re-read those files and retry. Prefer op "str_replace" for edits to existing files (send the exact snippet), "write" to create a file or replace one wholesale, "delete", and "move" to rename. move does NOT rewrite imports — neither in the files that import the moved module, nor the relative imports INSIDE the moved file, which now resolve from its new folder, so read it first and add the str_replace operations that fix them. The live preview updates from the new commit immediately. To rename an artifact or change its visibility use artifact-update_metadata; for very large repositories or full git workflows (branches, history rewriting) use artifact-get_git_token.
    Connector
    Destructive
    OAuth
  • Step 1 of adding a LARGE asset (an image, font or media file) to an EXISTING artifact — anything over 256 KB, which is the most artifact-edit takes inline. Smaller files need no staging: send them to artifact-edit directly with encoding "base64". **Flow:** 1. Call this with the sessionId and the filename: it returns assetUploadId, uploadUrl and uploadFields. 2. Upload the file with an HTTP POST of multipart/form-data to uploadUrl. Send EVERY key/value of uploadFields as a form field FIRST, then the file itself LAST, in a field named "file" — S3 ignores anything sent after the file part, so the order matters. Do not add a size or Content-Length field. Success is HTTP 204 with an empty body. With curl, uploadFields {"key": "abc", "policy": "xyz"} becomes: curl -X POST <uploadUrl> -F key=abc -F policy=xyz -F file=@/path/to/your-file.png 3. Call artifact-edit with a "write" change carrying assetUploadId instead of content, and the path the file should live at. Put the code that references it in the SAME edit, so both land in one commit. **Rules:** one file per id, single use, 30 minutes to redeem it, 32 MB max — S3 rejects a larger body at step 2. Files over 10 MB are stored through Git LFS automatically: the commit carries a small pointer and .gitattributes gains the matching filter line, with no extra steps on your side. uploadFields carry the signature that authorizes the upload; treat them as a secret. If your host cannot make an HTTP request, use artifact-edit with encoding "base64" for a file that fits inline, or artifact-get_git_token to push the file with git. **Returns:** success, assetUploadId, uploadUrl, uploadFields, expiresAt, maxBytes, nextSteps.
    ConnectorOAuth
  • Curated roster of the AI platforms and agent frameworks in the DC Hub agent ecosystem — each with its recommended DC Hub tools and authentication tier. The roster is BACKEND-OWNED and changes: read the platforms[] array the response returns, and the status on each row (mcp_active / mcp_ready), rather than any list named in this sentence — an enumeration here goes stale the moment the backend adds or drops a platform, which is exactly how a client named here stopped appearing in the roster. ★ These statuses are CURATED EDITORIAL claims, not measurements: the response carries as_of null, so do NOT relay "MCP Active" as though it were a live connection count. Answers "which AI platforms can connect to DC Hub". Try: get_agent_registry. NOTE: this is a curated ecosystem/capability index, NOT live per-caller call/citation telemetry. Do NOT use for platform uptime or feed health (use get_backup_status).
    ConnectorNo auth
  • Fetch a chart artifact generated by a council session or LOCUS determination. Returns the machine-readable spec (the data behind the chart) plus the stable SVG URL, or the raw SVG itself with include_svg=true. Artifact ids appear in session results as 'visualizations' / 'visualization' reference blocks. Requires authentication and enforces the artifact owner's tenant boundary.
    ConnectorNo auth
  • List every portfolio company with at least one live open role, most open roles first (paginated, 100 per page). Prefer list_collections for browsing by industry/hub/signal; use this for a raw roster.
    ConnectorNo auth
  • Update an EXISTING artifact's metadata — its display name and/or visibility. Metadata only: this never changes code or content. For content edits use artifact-edit (or the git flow via artifact-get_git_token); to deploy use artifact-publish; to create a new artifact use artifact-create. Requires sessionId — the id of an existing artifact (returned by artifact-create; if you have an artifact URL like https://app.agentgrid.io/artifacts/<sessionId>, it is the last path segment). Send at least one of name or privacy (both may be set in one call). Renaming requires write capability. Changing visibility requires share capability. Sending both fields requires both capabilities on the artifact. **Fields:** - sessionId (required) — the artifact to update. - name — new display name. - privacy — "public" (anyone with the link) or "private" (only the artifact's team). **Returns:** { success, message }
    Connector
    Destructive
    OAuth
  • Take an EXISTING published artifact offline — clears its live URL so the deployed site (app or markdown document) stops being reachable. The inverse of artifact-publish. This only affects the live deployment: it does NOT delete the artifact, its code, or its content, and the same subdomain is reused if you publish again later. Requires sessionId — the id of an existing, currently published artifact (returned by artifact-create; if you have an artifact URL like https://app.agentgrid.io/artifacts/<sessionId>, it is the last path segment). **Fields:** - sessionId (required) — the artifact to unpublish. **Returns:** { success, message }
    Connector
    Destructive
    OAuth
  • Get git access to an EXISTING artifact, for local development with a real git client. Use this when you HAVE a working shell with git and outbound network access AND the job suits a local checkout — a large refactor, running or testing the project, branches, or history rewriting. For ordinary reading and editing of an artifact’s files, prefer artifact-explore and artifact-edit: they need no shell, no git and no network of your own, and they change the same repository. An artifact is a real git repository. Pass the sessionId — the id of an existing artifact (e.g. the last path segment of a .../chat/<sessionId> URL, like "mr25vsjppVtbMx") — and this returns a gitRemoteUrl plus the authenticated principal’s commitAuthor. After cloning, apply the returned `git config user.name` and `user.email` instructions before committing; then edit files, commit, and `git push` — pushing updates the live artifact. The gitRemoteUrl holds a short-lived access token scoped to this one artifact (read-only or read-write, depending on your access). Tokens CANNOT be renewed: on a "token expired" git error, call this tool again for a fresh gitRemoteUrl and run `git remote set-url origin <new gitRemoteUrl>`, then retry. If a git command instead fails because the host cannot resolve or reach the server (DNS, proxy or firewall errors), do NOT retry it — that environment has no route to the git remote, so use artifact-edit instead. Treat the gitRemoteUrl as a secret. To rename an artifact or change its visibility, use artifact-update_metadata.
    ConnectorOAuth
  • Delete an EXISTING artifact. Use this tool only when the user explicitly asks you to delete that artifact. Do not infer deletion from a cleanup request. The tool makes a reversible soft deletion. It hides the artifact from normal lists and access paths. It keeps the artifact's code, assets, history, database content, and domain assignments. MCP cannot permanently delete an artifact. The tool needs write access. Unpublish a published artifact before you delete it. If a publish is in progress, wait for the publish to finish. Then call artifact-unpublish. Then call artifact-delete again. Set sessionId to the ID of the artifact to delete. An authorized repeated deletion succeeds. **Returns:** { success, message }
    Connector
    Destructive
    OAuth
  • v4 only. The assets held by one Aave v4 hub, with hub-wide supplied and borrowed totals, rates and utilisation. Get hubId from get_hubs (or the hubAddress on get_reserve_details). This is hub-level accounting; for what a user can actually supply or borrow, use get_markets, which is per spoke.
    ConnectorNo auth