Skip to main content
Glama
Artifacta MCP Server
by SagaPeak

Artifacta MCP Server

npm PyPI License: MIT

Official MCP server for Artifacta — an artifact store purpose-built for AI agents. Agents persist run outputs (files, reports, datasets, build results) with session and agent metadata, hand them off across sessions, and share them via expiring download links. Content-hash dedup means re-storing the same bytes is free.

Listed in the official MCP registry as io.artifacta/mcp.

Two implementations with the same tool surface, error contract, and path-confinement engine:

Directory

Package

Runtime

typescript/

@artifacta-mcp/mcp

Node 20+

python/

artifacta-mcp

Python 3.10+

Install as a Claude Code plugin

For Claude Code, the fastest path is the plugin marketplace this repo doubles as — it wires up the hosted server and a skill that persists run outputs automatically:

/plugin marketplace add SagaPeak/artifacta-mcp
/plugin install artifacta@artifacta

This bundles the same hosted MCP connection as the Quick start below plus the persisting-outputs skill (/artifacta:persisting-outputs, or it auto-triggers when a session has outputs worth saving). Update the plugin with /plugin marketplace update artifacta. See the plugin setup guide.

Related MCP server: Stela

Quick start

The fastest way to connect is the hosted server — no install, no API key:

claude mcp add --transport http artifacta https://mcp.artifacta.io/mcp

On first use your client self-registers via OAuth Dynamic Client Registration (PKCE) and opens a browser to authorize — no ak_live_ key to copy or store. See the hosted setup guide.

Local / CI (stdio)

For headless, air-gapped, or CI environments where a browser OAuth flow isn't available, run the package locally over stdio with an API key. Get a key at app.artifacta.io/dashboard/keys, then add to your MCP client config (Claude Desktop, Claude Code, Cursor, or any MCP client):

{
  "mcpServers": {
    "artifacta": {
      "command": "npx",
      "args": ["-y", "@artifacta-mcp/mcp"],
      "env": {
        "ARTIFACTA_API_KEY": "ak_live_..."
      }
    }
  }
}

Or run the Python implementation with pipx run artifacta-mcp.

See the per-package READMEs for config-file profiles, path confinement (--allow-path), destructive-tool gating (--allow-destructive), and troubleshooting: TypeScript · Python.

Tools

Tool

Description

whoami

Verify credentials; returns tenant and plan info

store_artifact

Upload an artifact from inline content or a local path

request_upload_url / complete_upload

Two-phase presigned upload for large files

get_artifact

Fetch artifact metadata by ID

get_artifact_download_url

Get a presigned download URL (1h expiry)

list_artifacts

List/filter artifacts by session, agent, or metadata

list_sessions

List active sessions

seal_session

Seal a session so no further artifacts can be added (gated behind --allow-destructive)

create_download_link

Create a public expiring share link (gated behind --allow-destructive)

delete_artifact

Soft-delete an artifact (gated behind --allow-destructive, same gate as create_download_link)

publish_artifact

Publish an artifact as a public page at artifacta.io/a/{slug} (Artifact Pages); idempotent, unlisted by default

unpublish_artifact

Take down an artifact's public page; the artifact itself is untouched; idempotent

Plus MCP resources for whoami, artifact metadata, artifact bytes, and sessions.

Safety defaults: local-file uploads are confined to an explicit --allow-path allow-list, and destructive tools (public share links, deletes, session seals) are hidden from clients that can't confirm writes unless --allow-destructive is passed. publish_artifact and unpublish_artifact are idempotent write operations, not destructive ones — they are not gated behind --allow-destructive.

Hosted OAuth connections (mcp.artifacta.io) add a second layer: the consent screen grants one of three scopes — artifacts:read ⊆ artifacts:write ⊆ artifacts:destroy. All 13 tools are always advertised in tools/list; calling a tool the token wasn't granted for returns a tool error with code insufficient_scope naming the missing scope, and the fix is to re-authorize with the broader scope. Scope gating applies only to hosted OAuth — ak_live_ API keys and local stdio remain full-access, using --allow-destructive / confirmation flags instead.

Framework integrations

The Python package ships optional adapters for OpenAI Agents SDK (pip install 'artifacta-mcp[openai-agents]') and LangChain/LangGraph (pip install 'artifacta-mcp[langchain]').

Documentation

Full docs at docs.artifacta.io/mcp/overview.

Development

# TypeScript
cd typescript && npm install && npm test

# Python
cd python && python -m venv .venv && source .venv/bin/activate
pip install -e '.[dev]' && pytest

This repository is published from the Artifacta monorepo; issues and PRs are welcome here.

License

MIT — see LICENSE.

Available Tools

8 tools
complete_uploadAInspect

Finalize an artifact previously reserved via request_upload_url after the bytes have been PUT to the presigned URL. Server verifies the blob, computes the content hash, transitions the artifact from pending to active, and increments tenant usage. Calling this on an already-active artifact is idempotent and returns the existing record. Calling before the PUT completes returns upload_not_found — wait and retry.

Inputs: artifact_id (required).

get_artifactA
Read-only
Inspect

Fetch metadata for a single artifact by ID: filename, content type, size, content hash, session/agent IDs, custom metadata, expiry, creation timestamp. Does NOT return the file bytes — call get_artifact_download_url for that. Returns artifact_not_found for unknown IDs, artifact_already_deleted (HTTP 410) for soft-deleted ones, artifact_expired (410) for those past their TTL.

Inputs: artifact_id (required).

get_artifact_download_urlA
Read-only
Inspect

Generate a short-lived presigned URL (1 hour) the agent can use to download the artifact's bytes directly from Cloudflare R2. Use this when the agent itself needs to consume the file. For sharing with humans, use create_download_link instead — that produces a stable dl.artifacta.io/lnk_… URL with configurable expiry.

Inputs: artifact_id (required).

list_artifactsA
Read-only
Inspect

List artifacts owned by the calling tenant, newest first. Supports filters by session_id, agent_id, filename (exact match), content_type, created_after / created_before (ISO 8601), and one or more metadata.<key>=<value> pairs (multi-key requires Pro). Returns a page of artifact records and a next_cursor to fetch the next page. Use this to discover what an agent or pipeline produced when you only know a session or agent ID.

Inputs: session_id, agent_id, filename, content_type, +5 more.

list_sessionsB
Read-only
Inspect

List session IDs synthesized from the calling tenant's artifacts, ordered by most recent activity. Each entry includes artifact count, seal status, and first/last activity timestamps. Sessions are not first-class — they exist only as long as artifacts reference them.

Inputs: created_after, created_before, limit, cursor.

request_upload_urlAInspect

Reserve a presigned R2 PUT URL for a file too large to send through store_artifact (over 500 MB up to 5 GB). Returns an upload_url, headers to include in the PUT, and an artifact_id in pending state. The agent (or its environment) PUTs the bytes directly to R2, then calls complete_upload. Pro plan only. Most agents should use store_artifact and let the MCP server pick the path automatically.

Not retry-safe: this endpoint does not support idempotency keys, so on an HTTP 5xx or network error the reservation may or may not have been created. Do NOT blindly retry — the error guidance tells you to first call list_artifacts with the same session_id/agent_id to detect any pending artifact, so you don't create a duplicate.

Inputs: filename (required), content_type (required), size_bytes (required), session_id, +3 more.

store_artifactA
Idempotent
Inspect

Upload a file as a new artifact in a single call. Provide EITHER up to ~10 MB of base64-encoded bytes via content, OR a local filesystem path that the MCP server reads and streams as multipart/form-data (up to 500 MB). For files larger than 500 MB, use request_upload_url (Pro only) instead — store_artifact returns file_too_large for them. Tags the artifact with session_id / agent_id / metadata for later retrieval and returns the full artifact record including its new artifact_id and content_hash.

Path uploads are confined. The path argument is constrained to the launcher-configured allow-list (default: the MCP server's CWD). Paths outside the allow-list, paths traversing symlinks out of it, and paths to known-sensitive locations (~/.ssh, ~/.aws, /etc/, etc.) are refused with invalid_request.

For crash-safe retries, supply your own idempotency_key (any string ≤256 chars): a replay within 24h returns the original artifact and never double-bills. If you omit it, the server auto-generates one and returns it under _meta.idempotency_key, but that key protects only in-process retries within a single call — it is lost if the server restarts, so pre-commit your own key when durability matters.

Inputs: filename (required), content, path, content_type, +5 more.

whoamiA
Read-only
Inspect

Return the calling tenant's identity, plan tier, current usage counters (storage bytes, monthly requests, active links), and rate limits. Use this once at the start of an agent run to confirm authentication and to size subsequent operations against quota. Free of side effects and quota-cheap.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool has a distinct purpose: upload (store_artifact vs request_upload_url/complete_upload), download (get_artifact_download_url vs get_artifact for metadata), listing (list_artifacts vs list_sessions), and identity (whoami). No overlaps.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case (e.g., complete_upload, get_artifact, list_artifacts, store_artifact). Even 'whoami' fits as a verb phrase.

    Tool Count5/5

    With 8 tools, the set is well-scoped for an artifact management server. Each tool covers a necessary operation without bloat.

    Completeness4/5

    Core lifecycle operations (upload, download, list, retrieve metadata) are covered, but missing update and delete tools, which is a minor gap.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      A local, agent-to-agent artifact exchange for LLM workflows. Enables MCP-capable tools like Claude, Codex, and Gemini to publish, list, read, update, and continue from artifacts without copying content through chat.
      578 npm
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Self-hosted MCP server for publishing, sharing, and reviewing AI agent artifacts with version history and pinned comments.
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables multi-agent systems to store large tool outputs and share only artifact IDs between agents, with access control, TTL, and audit logging.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to publish, retrieve, update, and delete hosted HTML, Markdown, Mermaid, and SVG artifacts and to create, list, or revoke shareable links through authenticated, scope-enforced tools. It exposes artifact hosting over Streamable HTTP so any MCP client can manage content on a self-hosted instance using a Bearer agent API key.
      2
      MIT