How to Integrate Fast.io MCP Server With Agent Workspaces

What is the Fast.io MCP Server?

The Fast.io MCP server connects AI agents directly to your cloud storage and knowledge bases via the Model Context Protocol.

It runs at /storage-for-agents/ and provides 251+ tools covering every UI capability as agent actions. Tools handle authentication, workspaces, storage, shares, AI chat, comments, workflow tasks, and ownership transfer.

Unlike raw S3 or ephemeral storage, Fast.io workspaces support human-agent collaboration, versioning, previews (video HLS streaming, PDF rendering), semantic search, and RAG without extra infrastructure.

Key benefits include free agent tier (50GB storage, 1GB files, 5 workspaces, no credit card), session management in Durable Objects, and dynamic resource discovery for files.

For developers, the server uses Streamable HTTP (/mcp) or legacy SSE (/sse). Session state persists across tool calls—no token passing needed.

Prerequisites and Account Setup

Start with a Fast.io agent account. Agents sign up via API—no UI needed.

Call auth signup with email/password. Verify email, then create an org with billing_plan "agent" for free tier.

Check credits with org billing usage. 5,000 monthly cover storage (100/GB), bandwidth (212/GB), AI (1/100 tokens).

Authenticate to MCP: use PKCE for secure browser login, API key from human account, or agent signin.

PKCE flow: auth pkce-login gets login_url, user approves, pkce-complete with code.

MCP Server Configuration JSON

Register Fast.io MCP in your agent client with this JSON:

{
  "mcpServers": {
    "fastio-mcp": {
      "url": "/storage-for-agents/",
      "name": "Fast.io Workspaces",
      "icon": "https://fast.io/icon.png",
      "description": "251+ tools for agent workspaces, storage, RAG, shares"
    }
  }
}

For SSE: "/storage-for-agents/".

Resources auto-discover: skill://guide for docs, download://workspace/{id}/{node} for files.

Test: list tools, auth status, resources/list.

Integrating with LangChain

LangChain supports custom tools. Create a FastIO tool wrapper using langchain.tools.

Install langchain-community if needed. Define tool calling with MCP endpoints.

Example Python code:

from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import tool
from langchain_openai import ChatOpenAI
import requests

@tool
def fastio_upload_file(content: str, workspace_id: str) -> str:
    """Upload content to Fast.io workspace via MCP."""
    # Call MCP auth if needed, then storage add-file
    response = requests.post("/storage-for-agents/", json={"tool": "storage", "action": "add-file", ...})
    return response.json()

llm = ChatOpenAI(model="gpt-4o")
tools = [fastio_upload_file]
agent = create_tool_calling_agent(llm, tools)
executor = AgentExecutor(agent=agent, tools=tools)

Bind MCP server as toolset. Use LCEL for chaining: auth → create workspace → upload → RAG query.

For RAG: scope chat_with_files to folders, get citations back.

Handle session: MCP stores token server-side.

Integrating with CrewAI

CrewAI uses tasks/agents/tools. Define Fast.io as custom tools.

Example:

from crewai import Agent, Task, Crew
from crewai_tools import tool

@tool("FastIO Workspace Manager")
def create_fastio_workspace(org_id: str, name: str) -> str:
    """Create workspace in Fast.io org."""
    # MCP call: workspace create
    return "Workspace ID: xxx"

researcher = Agent(role="Researcher", goal="...", tools=[create_fastio_workspace])
task = Task(description="Create workspace and upload report", agent=researcher)
crew = Crew(agents=[researcher], tasks=[task])
result = crew.kickoff()

Multi-agent: one agent manages storage, another RAG queries, third creates shares.

Ownership transfer task: build → generate transfer token → output claim URL.

Production Workflows and Best Practices

Enable intelligence for RAG. Use webhooks for reactive flows—no polling.

Multi-agent: file locks prevent conflicts.

Scale: free tier for dev, pro for prod (usage-based).

Troubleshooting: check auth status, credits, ai_state=ready for files.

Edge cases: large files chunked upload, scoped PKCE for permissions.

Monitor: activity poll for changes, worklogs for audit.