Setting Up Anthropic MCP Servers for Shared Agent Workspaces

Two coding agents pointed at the same local database or filesystem will happily overwrite each other's changes, and neither will notice. The limitation is not the intelligence of the model, but the single-user design of standard Model Context Protocol setups, where a Claude Desktop instance communicates with local servers over a one-to-one stdio connection. When developers configure their workspaces using these defaults, they establish isolated silos. Under a typical developer setup, an agent runs as a local process, executing commands and reading files on a single workstation. If another team member or a remote agent needs to collaborate on the same codebase, they cannot access those local resources. This isolation prevents teams from sharing tool configurations, state, and context.

In standard installations, the Model Context Protocol relies on standard input and standard output streams for communication. When the AI client starts, it spawns the server as a child process and reads its stdout while writing to its stdin. This design makes it impossible to share a single server instance among multiple clients or team members. Every developer on the team must run their own copy of the server, leading to duplicate credentials, disjointed configuration parameters, and inconsistent local environments. For instance, a Postgres database connection string or a GitHub personal access token must be configured individually on every developer workstation, increasing the surface area for credential leaks.

To resolve these barriers, teams must transition from local process execution to network-accessible services. The anthropic model context protocol provides a structured way to connect clients and servers, but running them over standard input/output (stdio) limits connectivity to a single client process. By configuring anthropic mcp servers to run over Server-Sent Events (SSE), organizations can run these utilities as web services. This configuration allows multiple clients, including human team members and independent AI agents, to connect to the same server simultaneously. A remote database tool, a shared filesystem, or an API wrapper can be run once in the cloud and shared by the entire team. This architectural shift enables collaborative agent rooms where multiple agents coordinate, query the same data repositories, and build upon each other's outputs.

• How to Integrate MCP Servers with Claude CoworkGuide to claude cowork mcp integration: The Model Context Protocol (MCP) gives Claude direct access to your databases,...
• How to Integrate MCP with Claude - Complete Setup GuideClaude MCP integration connects Anthropic's Claude AI to external tools and data sources through the Model Context...
• Claude Code Proxy Setup: Corporate Networks, API Gateways, and ANTHROPIC_BASE_URLCorporate proxy servers, TLS inspection appliances, and API gateways all sit between Claude Code and the Anthropic API....
• How to Setup Claude Coworking Workspaces for Research TeamsResearch teams often struggle with fragmented literature and disorganized data silos. Claude Coworking acts as a...
• How to Build a Claude MCP Coworking Setup for Your TeamA Claude MCP coworking setup involves connecting shared tools and data sources to Claude via the Model Context...
• Cline vs Claude Code: The Best Agent for MCP WorkspacesWhile Anthropic's Claude Code brings native CLI capabilities, Cline’s open-source architecture and 1-click MCP...

More on this subject: Claude and Claude Code (159 guides)

Getting started with the official reference implementations requires installing the necessary packages from the official Model Context Protocol servers repository. Anthropic's official servers repo contains pre-built integrations for Postgres, Puppeteer, GitHub, and local Filesystems. This repository is maintained by the open-source community alongside the core developers to provide a set of standard utilities. For local testing and development, developers can install these servers using package managers like npm or uv.

For example, to run a filesystem server locally, you can use the npx command. To do a standard claude mcp setup for a single user, you edit the local configuration file. On macOS, this file is located at ~/Library/Application Support/Claude/claude_desktop_config.json, and on Windows, it is at %APPDATA%\Claude\claude_desktop_config.json. The configuration defines the commands, arguments, and environment variables required to run each server as a subprocess.

Here is a typical single-user configuration snippet. It shows how the local client runs a filesystem server and a GitHub server using standard command arguments:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/tom/project-folder"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your_access_token_here"
      }
    }
  }
}

While this single-user approach is simple to establish, it does not scale to team environments. The local paths are hardcoded to a specific workstation, and the API keys are exposed within a local JSON file. If another developer wants to run the same agent, they must replicate the installation, configure their own environment variables, and manage local access credentials. Furthermore, Windows users often encounter command execution errors when running raw npx scripts. These setups require wrapping the command with cmd.exe using the appropriate parameters. To build a collaborative environment, the team must run the official anthropic mcp servers as web services that communicate over HTTP using Server-Sent Events.

How do I run official MCP servers with SSE instead of stdio? Transitioning from stdio to SSE requires wrapping the server inside an ASGI application that can handle persistent web connections. In this architecture, the server runs continuously in the cloud, exposing two key routes. The first route is a GET endpoint that initiates the Server-Sent Events stream from the server to the client. The second route is a POST endpoint that receives incoming JSON-RPC messages from the client.

You can implement this wrapper using the Python SDK for the Model Context Protocol. The SDK provides the SseServerTransport class to manage the ASGI connections. The following example demonstrates how to wrap an MCP server using Starlette, exposing it over a network-accessible port:

import asyncio
from mcp.server.fastmcp import FastMCP
from mcp.server.sse import SseServerTransport
from starlette.applications import Starlette
from starlette.routing import Route, Mount
from starlette.responses import JSONResponse

mcp = FastMCP("Shared Team Server")

@mcp.tool()
def fetch_project_status(project_name: str) -> str:
    """Retrieve the current development status of a project."""
    return f"Project {project_name} is active and synchronized."

sse = SseServerTransport("/messages")

async def handle_sse(request):
    async with sse.connect_sse(
        request.scope, 
        request.receive, 
        request._send
    ) as streams:
        await mcp._mcp_server.run(
            streams[0],
            streams[1],
            mcp._mcp_server.create_initialization_options()
        )
    return JSONResponse({"status": "disconnected"})

routes = [
    Route("/sse", endpoint=handle_sse, methods=["GET"]),
    Mount("/messages", app=sse.handle_post_message),
]

app = Starlette(routes=routes)

Once this server is running on a cloud VM or container, any team member can connect to it by editing their client settings. Instead of defining a command and arguments, the configuration points directly to the remote URL. For example, if you deploy this server to an internal domain, you can configure your client with the following JSON block:

{
  "mcpServers": {
    "team-shared-server": {
      "type": "sse",
      "url": "http://localhost:8000/sse"
    }
  }
}

Configuring Anthropic servers with SSE (Server-Sent Events) allows multi-client connections, bypassing the stdio limitation. The server handles multiple connections, routing responses back to the correct client based on the session identifier. This transition makes the server a shared network resource rather than a local subprocess.

When deploying SSE servers in production, teams must address network security and authentication. Since these endpoints are exposed over HTTP, you must implement token-based authorization. Clients should attach a secure bearer token to the headers of their GET and POST requests. Configuring CORS policies is critical to prevent unauthorized cross-origin requests from web-based clients. If the server is deployed behind a reverse proxy like Nginx or Cloudflare, ensure that connection timeouts and buffer size parameters are optimized for long-lived HTTP streams.

Coordinate shared agents in a unified workspace

A shared workspace with an MCP-ready endpoint for your agent's reads and writes, with versioning and search built in. Starts with a 14-day free trial.

Start 14-Day Trial

Which Anthropic MCP servers are supported in team workspaces? Any official or community server can be deployed over SSE if wrapped in a network transport layer. In collaborative team rooms, the active reference servers like Filesystem, Git, Memory, and Fetch play a central role. For example, a shared Git server deployed in the cloud can allow multiple agents to read repository metadata, check branches, and inspect commits. Similarly, a shared database server running over SSE allows agents to query data, run reports, and inspect tables on behalf of the whole team.

However, sharing a raw filesystem or database directly across multiple independent agents introduces security and concurrency challenges. If three different agents run git commands on a single remote directory simultaneously, they can easily cause merge conflicts, overwrite changes, or corrupt the local index. Exposing a raw local filesystem over the internet requires managing network ports, domain names, and transport security parameters to prevent unauthorized command execution.

To avoid these infrastructure hurdles, teams use a cloud workspace platform like Fast.io. Fast.io serves as the central intelligent workspace for agentic teams, providing a secure, version-controlled repository for files, shares, and notes. Instead of managing individual filesystem servers, the team connects to the remote Fast.io MCP server. The Fast.io MCP server runs remotely over streamable HTTP at https://mcp.fast.io/mcp or https://mcp.fast.io/mcp/key using an organization API key.

By using Fast.io as the coordination substrate, teams get several built-in advantages:

• Per-File Version History. Every file stored in a Fast.io workspace retains a complete version history. If an agent writes an incorrect output or overwrites a colleague's file, you can restore previous versions. This structure eliminates conflicts when multiple agents read and write to the same files.
• Built-in Semantic Search. Once you enable Intelligence on a workspace, Fast.io automatically indexes all files on arrival. Agents and humans can perform hybrid search, combining exact full-text matches with semantic retrieval, and receive answers with citations.
• Granular Access Control. Access to workspaces, folders, and shares can be configured with granular permissions, ensuring that agents only access the specific directories they need.

When multiple agents and humans coordinate within a single Fast.io workspace, clear organizational boundaries prevent conflicts. Developers should design workspaces with structured directory layouts, separating raw inputs, staging areas, and finished work. For instance, you can configure a research agent to download source documents from a Fast.io Receive folder, perform analysis, and write the output into a specific staging folder.

Once the data is written, the research agent can hand off the work to a writer agent. Rather than trying to coordinate these agents through direct API integrations, the hand-off occurs through the shared workspace itself. The writer agent reads the staging folder, generates the report, and writes it to a final delivery folder. To keep the team informed, the agent can post updates to a shared Coordination Room. Coordination Rooms support webhooks for events like room.message.created and room.participant.status_changed, letting you build reactive workflows. Alternatively, agents can use the workspace activity long-poll at /current/activity/poll/{entity_id} to check for new file events.

For structured data extraction, agents can use Fast.io's Metadata Views. Metadata Views turn raw documents into a live, queryable database. You describe the columns you want extracted in natural language, and Fast.io designs a schema using fields like Text, Integer, Decimal, Boolean, URL, JSON, or Date & Time. The AI matches files in the workspace, extracts the fields, and populates a filterable database. Agents can configure schemas, trigger extraction, and query results programmatically. Learn more about document data extraction at the /product/document-data-extraction/ product page.

When the agent's work is complete, it can transfer ownership of the organization to a human. This ownership transfer capability allows the agent to create the organization, configure the workspaces, set up the initial directory structure, and then send a claim link to a human team member. The agent retains administrative access while the human assumes financial and organizational ownership.

Every organization starts with a 14-day free trial, which requires a credit card. Plans: Starter, Business, and Growth at $29/mo | $99/mo | $299/mo. This ensures the team has access to the full suite of collaborative notes, branded sharing portals, and hybrid search.

To manage this environment effectively, teams must also review the append-only audit log. The audit log provides an immutable record of every file upload, download, and modification, detailing which agent or human initiated the action. If an error occurs, developers can trace the actions back through the activity log to understand exactly when a file was modified. By using these features, teams can deploy remote Anthropic MCP servers to perform database and network operations, while using Fast.io to manage the collaborative file sharing, search, and storage layer.