Fastio MCP Server Integration Guide for Developers

The Fastio MCP server is a remote Model Context Protocol server, hosted by Fastio, that exposes workspaces, shares, files, and the built-in AI layer to any MCP-capable client. It is reached at https://mcp.fast.io/mcp.

The word remote is the whole design, and it is the detail most integration guides get wrong. There is no npm package to install, no binary to download, and no subprocess for your client to spawn. Your client opens an HTTP connection to a URL that Fastio operates. In practice that means a client configuration block for Fastio carries a url field, never a command and args pair. If you are copying a config that starts with npx, it is not configuring this server.

That single fact removes most of the work. You are not running infrastructure, you are not versioning a local server against the protocol, and you do not have to redeploy anything when the tool surface changes. You point a client at a URL and authenticate.

Fastio exposes a consolidated MCP toolset rather than a sprawl of single-purpose endpoints. The tools cover the same ground a person covers in the web interface: creating and organizing workspaces, moving files, building shares, importing from other clouds, running semantic search and citation-backed chat, reading structured data out of documents, following activity, and transferring ownership of an organization to a human.

New to the protocol itself? Start with the Model Context Protocol explainer. If you are choosing a client, see the MCP client comparison.

• Fastio MCP Server Docker Compose Setup GuideUsing Docker Compose to set up agent environments that connect to the remote Fastio MCP server provides a stable...
• How to Implement Fastio SSE Streaming for MCP ToolsSSE (Server-Sent Events) streaming over MCP allows Fastio to push real-time file updates, extraction progress, and tool...
• How to Implement Fastio MCP with LangGraphIntegrating Fastio's MCP server with LangGraph lets your stateful agent workflows read, write, and share files across...
• How to Implement OpenTelemetry Tracing for Fastio MCP ServersLearn how to implement OpenTelemetry tracing for Fastio MCP servers to see how your AI agents actually work. This guide...
• Top 7 MCP Servers for Databases: Connecting Agents to Data (2026)MCP servers for databases connect AI agents to structured data storage. This guide ranks the top multiple servers for...
• What Is Model Context Protocol (MCP)?Model Context Protocol (MCP) is an open standard that lets AI agents connect to external data sources and tools through...

More on this subject: MCP and Model Context Protocol (195 guides)

Fastio publishes three endpoints. They differ in transport and in how they expect credentials to arrive, not in what tools they expose.

Streamable HTTP is the current transport and the one to build against. The SSE endpoint is kept for clients that have not migrated yet. There is no third option in which the server runs on your machine, because this server does not run on your machine.

There is one genuine local path, and it belongs to a different product. The Fastio CLI ships its own MCP server, started with fastio mcp, for clients that can only spawn a local stdio process. That is the CLI's server, not this one. Reach for it when a client gives you no way to enter a URL, and treat the two as separate integrations rather than two modes of the same thing. A longer treatment of the transport choice lives in Streamable HTTP versus SSE.

Two credential paths reach the same tools, and the right one depends on whether a human is present at setup time.

OAuth, for interactive clients. Browser-based login means an agent never handles your password. The client sends you to Fastio, you approve, and the client receives a token. This is the path to use in a desktop client or an editor, and it is the default at https://mcp.fast.io/mcp.

Scoped API keys, for everything unattended. A human creates a key and grants it to the agent. Keys are scoped, so a key can be limited to specific organizations, workspaces, or shares rather than everything the creating user can see. Point the client at https://mcp.fast.io/mcp/key and send the key as a bearer token. Two-factor authentication can be required for API-key management itself, which keeps key creation behind a second factor even when key use is automated.

Scope keys narrowly. An agent that writes weekly reports into one workspace needs a key for one workspace. If that agent misbehaves, the blast radius is the workspace you gave it and nothing else. This is the single highest-leverage decision in an agent integration and it costs nothing to get right at setup. There is more on the threat model in MCP server security.

If you are scripting key creation, fastio auth api-key create --name "CI pipeline" does it from the CLI. The CLI reads FASTIO_API_KEY or FASTIO_TOKEN from the environment and keeps profiles under ~/.fastio/.

Every MCP client wants the same three things: a name, a URL, and a way to attach credentials. The syntax differs, the shape does not.

For a client that handles OAuth, the entry is close to minimal:

{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp"
    }
  }
}

For an unattended client using a scoped key, point at the key endpoint and send a bearer header:

{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer ${FASTIO_API_KEY}"
      }
    }
  }
}

Read the key from the environment rather than pasting it into a file you will later commit. Restart the client after saving, and it will negotiate the connection and list the available tools to the model.

Clients vary in where that JSON lives and in whether they support remote servers at all, which is the practical constraint worth checking first. If a client can only spawn a local process, use the CLI's fastio mcp server described above rather than trying to force a URL into a command field.

Point your agent at a workspace it can keep

Connect the remote MCP server, give your agent a scoped key, and hand the finished workspace to a human when the job is done. Every org starts on a 14-day trial.

Try the MCP Server

The toolset is consolidated, so a small number of tools cover a lot of surface. It is more useful to think in terms of what an agent can accomplish than to count tool names.

Workspaces and files. Agents create workspaces, organize folders, move and copy files, and read file metadata. Uploads use chunked sessions, so large files do not need to fit in a single request. Maximum file size depends on the active plan.

Shares. Send, Receive, and Exchange shares are distinct types rather than one link with flags. An agent can build a Send share for delivering work, a Receive share to collect files from someone with no account, or an Exchange share for two-way work. Shares support branding, guest access, download controls, and passwords where the share type and access mode allow. Single-file shares can be durable or set to expire, carry per-recipient grants you can revoke individually, and are versioned so recipients see the current file with history available.

Import from elsewhere. Rather than pulling a file down and pushing it back up, an agent can have Fastio fetch it directly from Google Drive, Dropbox, OneDrive, or Box over OAuth, with folder structure preserved, or from any public URL. The bytes never round-trip through the agent's host.

The AI layer. When Intelligence is enabled, files are indexed for semantic search, summarization, and citation-backed chat. Search combines exact full-text matching with meaning-based retrieval and returns the matching passages, not just the matching files. Metadata Views go a step further and turn documents into a queryable table: describe the columns you want in plain language, and extraction populates a typed, filterable grid you can sort and click through to the source document. Agents can drive Views programmatically, which is the difference between an agent that can read a folder of contracts and one that can answer questions across them.

Activity. Agents can poll or subscribe to workspace and share activity instead of walking every resource looking for changes. Activity can also be searched and summarized into a natural-language account of what happened.

One default worth knowing: agent-created workspaces have Intelligence enabled from the start, and Intelligence cannot be re-enabled once it has been disabled. Decide deliberately before turning it off.

Framework integrations differ less than their documentation suggests, because they are all solving the same problem: hand the model a set of tools and a way to call them.

If the framework has first-class MCP support, the work is configuration. Register a remote server with the URL and credentials above, and the framework handles discovery and tool-calling. Nothing Fastio-specific is required.

If the framework has no MCP support, do not wait for it and do not go looking for a Fastio client library, because there is not one in any language. Call the REST API directly with whatever HTTP library the language already has: requests in Python, fetch in JavaScript, reqwest in Rust. The API is the same surface the MCP server sits on top of, and a plain HTTP call is less code than an adapter. Any tutorial offering you a Fastio SDK to install is describing a package that does not exist.

If the framework runs somewhere you cannot easily hold a browser session, use a scoped API key against the /mcp/key endpoint. This is the common shape for scheduled jobs, CI, and long-running services.

The pattern that makes agent work durable is the handoff. An agent can build an organization, populate it, and then transfer ownership to a human through a claim link. The human ends up owning a workspace they can log into and keep, and the agent can retain access to continue maintaining it. That is what separates an agent that produced some files from an agent that delivered something.

Autonomy is only comfortable when it is reviewable, and three mechanisms carry that here.

The audit log is append-only and records activity by people and agents, including file operations, membership changes, comments, AI activity, and billing events. When an agent does something surprising at 3am, use the audit log and activity feed to review what happened and when.

Permissions are granular at every level. Organizations, workspaces, shares, folders, and files each carry their own controls, so read-only access to one folder is expressible rather than approximated.

Version history is complete. Every file keeps its versions and prior ones can be restored, which is the practical answer to an agent that overwrites something it should not have. Recipients of a share always see the current version, with history available.

Fastio runs on certified infrastructure partners including Google Cloud and Cloudflare. Fastio itself does not hold SOC 2, ISO 27001, or HIPAA certification, so if your procurement process requires a certificate in Fastio's own name, raise it early rather than late.

Pricing uses usage-based credits with per-plan seat and storage limits, which lets teams match capacity to both agent workloads and human collaborators.

Every organization can activate a 14-day Business Trial with a credit card. It runs with Business-plan capabilities for those 14 days. There is no permanent free plan or separate free tier for agents. Afterward, Starter is $29 per month for 5 seats, 1 TB of storage, and 300,000 credits per month; current Business and Growth details are on the pricing page.

Credits meter what you actually consume: storage per gigabyte, bandwidth per gigabyte, AI tokens, document and media ingestion, and file conversions. For an agent integration the ingestion meters are usually the ones to model first, because indexing a large document set is a one-time cost that dwarfs the steady state.

There is a signup path worth knowing for agent-first products: an agent can sign up on its own, do the work, and then hand the organization to a human who creates or joins it and starts the trial.