How to Connect Fastio MCP Server to AutoGen Agents

AutoGen is Microsoft's open-source framework for building multi-agent applications. You define agents with specific roles, give them tools, and let them collaborate on tasks. The framework handles message routing, tool execution, and conversation management.

The gap shows up when agents need to persist their work. By default, AutoGen agents operate in memory. A coding agent generates a script, a reviewer reads it, and an executor runs it, all within the same session. When that session ends, the files disappear. If you deploy agents in Docker containers or serverless functions, local disk storage is wiped on restart.

This creates three problems in production:

• No persistence. Outputs from one session are unavailable in the next. Long-running projects that span hours or days lose continuity.
• No sharing. Agent A writes a file to its local disk. Agent B, running in a different process or container, cannot access it without a custom file-transfer mechanism.
• No handoff. When agents finish their work, there is no built-in way to package and deliver results to a human client.

Cloud object stores like S3 solve the persistence problem, but they do not provide search, access control at the file level, or a collaboration layer. Fastio fills that gap by acting as an intelligent workspace that both agents and humans can access through the same interface.

The connection between AutoGen and Fastio uses the Model Context Protocol (MCP), an open standard for giving language models access to external tools and data. Fastio runs an MCP server that exposes 19 consolidated tools covering workspace management, file operations, AI-powered search, sharing, and workflow actions.

AutoGen supports MCP through its autogen-ext[mcp] extension package. This package provides adapter classes that connect to any MCP server and expose its tools as standard AutoGen tools. Your agents call them the same way they call any other function.

The data flow looks like this:

1. Your AutoGen agent decides it needs to upload a file or search a workspace.
2. The agent calls the appropriate MCP tool through the adapter.
3. The adapter sends the request to Fastio's MCP endpoint over Streamable HTTP.
4. Fastio executes the operation and returns the result.
5. The agent receives the response and continues its workflow.

Fastio exposes two transport options: Streamable HTTP at /storage-for-agents/ (recommended) and legacy SSE at /storage-for-agents/ The Streamable HTTP transport is the current MCP standard and what AutoGen's newer adapter classes target. For the full tool reference, see Fastio's MCP documentation.

You need Python 3.10 or higher, an AutoGen installation with MCP support, and a Fastio account. The free agent plan gives you 50 GB of storage, 5,000 monthly credits, and 5 workspaces with no credit card required.

Start by installing the required packages:

pip install -U "autogen-agentchat" "autogen-ext[mcp]"

The autogen-ext[mcp] package installs the MCP adapter classes and the mcp_server_tools helper function. Next, create a Fastio account at fast.io/pricing/ and generate an API key from your account settings.

Store your credentials as environment variables:

export FASTIO_API_KEY="your-api-key-here"
export OPENAI_API_KEY="your-llm-api-key-here"

AutoGen works with any LLM provider. You can use OpenAI, Anthropic, Google Gemini, or a local model through an OpenAI-compatible API. The MCP integration is independent of which model powers your agents.

Verify the installation by checking that the adapter imports resolve:

from autogen_ext.tools.mcp import (
    StreamableHttpMcpToolAdapter,
    StreamableHttpServerParams,
    mcp_server_tools,
)
print("MCP adapter loaded successfully")

If you see an import error, confirm that your autogen-ext version is 0.4 or higher. Earlier versions used a different module structure.

Give your AutoGen agents a workspace they can keep

Connect your multi-agent teams to persistent cloud storage with built-in RAG, file sharing, and human handoff. 50 GB free, no credit card required.

Sign Up Free

With the environment ready, you can connect your AutoGen agents to Fastio. The StreamableHttpMcpToolAdapter class handles the connection to Fastio's Streamable HTTP endpoint.

Here is a working example that creates an AutoGen agent with access to all Fastio MCP tools:

import asyncio
import os
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import (
    StreamableHttpMcpToolAdapter,
    StreamableHttpServerParams,
    mcp_server_tools,
)

async def main():
    # Configure the Fastio MCP server connection
    server_params = StreamableHttpServerParams(
        url="/storage-for-agents/",
        headers={
            "Authorization": f"Bearer {os.environ['FASTIO_API_KEY']}"
        },
        timeout=30.0,
        sse_read_timeout=300.0,
        terminate_on_close=True,
    )

# Retrieve all available tools from the server
    tools = await mcp_server_tools(server_params)

# Create an agent with Fastio tools
    model_client = OpenAIChatCompletionClient(model="gpt-4o")
    agent = AssistantAgent(
        name="file_manager",
        model_client=model_client,
        tools=tools,
        system_message=(
            "You are a file management agent. Use the Fastio "
            "workspace tools to organize, search, and share files."
        ),
    )

# Run a task
    from autogen_agentchat.teams import RoundRobinGroupChat
    from autogen_agentchat.conditions import TextMentionTermination

termination = TextMentionTermination("TERMINATE")
    team = RoundRobinGroupChat([agent], termination_condition=termination)

result = await team.run(task="List all workspaces available to me.")
    print(result)

asyncio.run(main())

The mcp_server_tools function connects to the Fastio server, discovers all available tools, and returns them as AutoGen-compatible tool objects. If you only need specific tools, you can use the individual adapter instead:

# Load a single tool by name
upload_tool = await StreamableHttpMcpToolAdapter.from_server_params(
    server_params, "storage"
)

This approach keeps your agent's context window lean. Loading all 19 tools works well for general-purpose agents, but specialized agents perform better with a focused tool set.

The real value of this integration appears when multiple agents share a workspace. A common AutoGen pattern is the planner-coder-reviewer team, where each agent has a distinct role and they coordinate through message passing.

Here is how to structure that team with Fastio as the shared storage layer:

The Research Agent uses Fastio's Intelligence Mode to query existing documents. When Intelligence is enabled on a workspace, all uploaded files are automatically indexed for semantic search. The agent asks natural-language questions and gets answers with citations, without downloading or parsing files locally.

The Writer Agent generates content and uploads it to a designated folder in the workspace. It uses workspace tools to create organized folder structures and set appropriate file metadata.

The Reviewer Agent gets notified of new files through Fastio webhooks, reads the content from the workspace, and posts feedback. Because every agent accesses the same workspace, there is no file copying or format conversion.

research_agent = AssistantAgent(
    name="researcher",
    model_client=model_client,
    tools=tools,
    system_message=(
        "You research topics using the Fastio workspace. "
        "Use the AI query tools to search indexed documents. "
        "Summarize findings for the writer agent."
    ),
)

writer_agent = AssistantAgent(
    name="writer",
    model_client=model_client,
    tools=tools,
    system_message=(
        "You write reports based on research findings. "
        "Upload completed drafts to the workspace using "
        "the storage tools."
    ),
)

Fastio's file locks prevent conflicts when two agents try to modify the same file simultaneously. Agent A acquires a lock, makes its changes, and releases the lock. Agent B waits for the lock to clear before reading the updated version. This eliminates race conditions that plague shared-filesystem approaches.

For reactive workflows, configure Fastio webhooks to trigger agent tasks when files change. Instead of polling for updates, your agents wake up only when there is new work. This is both faster and cheaper in terms of API credits.

Agents produce work. Humans consume it. The gap between those two steps is where most agent workflows break down. An AutoGen team might generate a complete project deliverable, but without a clean handoff mechanism, the output sits on a server somewhere that the client cannot easily access.

Fastio's ownership transfer feature solves this directly. An agent creates a workspace, populates it with files, and then transfers ownership to a human user via their email address. The human receives access to a polished workspace with file previews, version history, and download options. The agent can optionally retain admin access for ongoing maintenance.

The workflow in practice:

1. Agent creates a new workspace for the project.
2. Agent uploads reports, code, and supporting documents.
3. Agent enables Intelligence Mode so the client can search the contents.
4. Agent transfers ownership to the client's email.
5. Client opens the workspace in their browser and reviews everything.

This turns agent output into a professional deliverable. The client does not need to install anything, learn a new tool, or parse raw API responses. They get a workspace that looks and works like a product they already understand.

For teams that need branded delivery, Fastio's Share features (Send, Receive, and Exchange) let agents create custom-branded file transfer links. A consulting firm's agent can deliver work through a portal that carries the firm's branding, not Fastio's.

Import errors after installing autogen-ext. Make sure you installed the MCP extra specifically: pip install "autogen-ext[mcp]". The base autogen-ext package does not include MCP adapters.

Authentication failures (401 or 403 responses). Double-check that your API key is passed in the Authorization header with the "Bearer" prefix. Keys generated for one Fastio organization will not work for another.

Context window overflow with smaller models. Loading all 19 Fastio tools adds to the system prompt that gets sent with every request. If you are using a model with a smaller context window, load only the tools your agent actually needs using StreamableHttpMcpToolAdapter.from_server_params() with a specific tool name.

Timeouts on large file uploads. The default timeout of 30 seconds may not be enough for files over 100 MB. Increase the timeout parameter in your StreamableHttpServerParams configuration. Fastio supports chunked uploads for large files.

SSE transport deprecation warnings. If you are using the SseMcpToolAdapter with Fastio's /sse endpoint, you may see deprecation notices. The MCP standard has moved to Streamable HTTP as the primary transport. Migrate to StreamableHttpMcpToolAdapter pointed at /mcp to stay current.

Agent loops consuming credits. A misconfigured agent can enter a retry loop that burns through your monthly credit allocation. Set a maximum iteration count on your AutoGen team and monitor usage through the Fastio dashboard. The free tier provides 5,000 credits per month.

For endpoint documentation and the complete tool schema, visit /storage-for-agents/. For general agent onboarding, see https://fast.io/llms.txt.