Artifacta MCP Server
The Artifacta MCP Server is an artifact store for AI agents, enabling them to persist, manage, and share run outputs (files, reports, datasets, build results) across sessions with content-hash deduplication and secure access.
Verify identity & quota (
whoami): Confirm authentication and retrieve tenant info, plan tier, storage usage, request counts, and rate limits.Upload artifacts (
store_artifact): Upload via inline base64 (≤10 MB) or local file path (≤500 MB), tagged with session/agent IDs and custom metadata. Supports idempotency keys for crash-safe retries.Upload large files (
request_upload_url+complete_upload): Two-phase upload for files up to 5 GB — reserve a presigned R2 PUT URL, upload directly, then finalize (Pro plan only).Fetch artifact metadata (
get_artifact): Retrieve filename, content type, size, content hash, session/agent IDs, custom metadata, expiry, and timestamps for a specific artifact.Download artifacts (
get_artifact_download_url): Generate a short-lived (1-hour) presigned URL to download artifact bytes directly from Cloudflare R2.List & filter artifacts (
list_artifacts): Filter by session, agent, filename, content type, date ranges, or custom metadata key/value pairs, with cursor-based pagination.List sessions (
list_sessions): View active sessions with artifact counts, seal status, and activity timestamps.Seal sessions (
seal_session): Lock a session to prevent further artifact uploads.Create public share links (
create_download_link): Generate stable, expiring public links for sharing artifacts with humans (requires--allow-destructive).Delete artifacts (
delete_artifact): Soft-delete an artifact (requires write confirmation).Safety: Local file uploads are path-confined to an allow-list; destructive tools are gated behind
--allow-destructive.
Provides optional integrations for LangChain/LangGraph to persist and share artifacts from agent runs.
Provides optional integrations for LangChain/LangGraph to persist and share artifacts from agent runs.
Provides adapters for the OpenAI Agents SDK to enable AI agents to store and retrieve artifacts.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Artifacta MCP Server
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 |
Node 20+ | ||
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@artifactaThis 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/mcpOn 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 |
| Verify credentials; returns tenant and plan info |
| Upload an artifact from inline content or a local path |
| Two-phase presigned upload for large files |
| Fetch artifact metadata by ID |
| Get a presigned download URL (1h expiry) |
| List/filter artifacts by session, agent, or metadata |
| List active sessions |
| Seal a session so no further artifacts can be added (gated behind |
| Create a public expiring share link (gated behind |
| Soft-delete an artifact (gated behind |
| Publish an artifact as a public page at |
| 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]' && pytestThis repository is published from the Artifacta monorepo; issues and PRs are welcome here.
License
MIT — see LICENSE.
Available Tools
8 toolscomplete_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_artifactARead-onlyInspect
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_urlARead-onlyInspect
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_artifactsARead-onlyInspect
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_sessionsBRead-onlyInspect
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_artifactAIdempotentInspect
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.
whoamiARead-onlyInspect
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
Scored across 8 tools
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.
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.
With 8 tools, the set is well-scoped for an artifact management server. Each tool covers a necessary operation without bloat.
Core lifecycle operations (upload, download, list, retrieve metadata) are covered, but missing update and delete tools, which is a minor gap.
Maintenance
Related MCP Connectors
Private, expiring artifact hosting for AI agents. Upload via API or MCP; links die on their own.
Artifact store for AI agents — read, write, and search files by path; share by rendered URL.
Searchable storage for AI agents: store, find, read and trust artifacts shared between agents.
1Shared workspace for AI artifacts: your agents publish, search and cite each other's work.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceA 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 npmMIT
- AlicenseNot gradedqualityDmaintenanceSelf-hosted MCP server for publishing, sharing, and reviewing AI agent artifacts with version history and pinned comments.MIT
- FlicenseNot gradedqualityDmaintenanceEnables multi-agent systems to store large tool outputs and share only artifact IDs between agents, with access control, TTL, and audit logging.-
- AlicenseNot gradedqualityBmaintenanceEnables 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.2MIT