# How to Connect Claude to a Google Shared Drive or Network Drive

Connecting Claude to a shared drive links Anthropic's AI models to organizational team drives and shared storage through an indexed MCP workspace, bypassing personal drive API constraints. Standard connectors fail on Google Shared Drives without explicit drive flags and struggle with latency on SMB network shares. By importing files into an indexed workspace, teams query documentation through remote MCP tools without hitting API quotas or filling context windows.

Source: https://fast.io/resources/connect-claude-to-shared-drive/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-03

## The Context Gap Between Claude and Organizational Shared Storage

When an engineering or operations team connects Claude to Google Drive, the integration almost always breaks at the boundary between personal files and team storage. Claude can see spreadsheets and slide decks sitting in an individual user's My Drive, but the moment a prompt asks for an architectural specification or contract stored in a Google Workspace Shared Drive, the model reports that the folder is empty or that the file does not exist. A similar breakdown occurs with local network drives: mounting a multi-terabyte SMB or NFS share to a local filesystem MCP server forces Claude to crawl directory trees over high-latency network protocols, triggering 60-second tool timeouts and exhausting conversation context.

Connecting Claude to a shared drive links Anthropic's AI models to organizational team drives and shared storage through an indexed MCP workspace, bypassing personal drive API constraints. The Model Context Protocol (MCP) provides an open standard for exposing external data repositories, runtime developer tools, and enterprise context to language models without requiring brittle, custom integration scripts.

Most introductory guides for Claude focus exclusively on personal storage environments. They demonstrate how to authenticate a single user account to read files from My Drive or show how to point Claude Desktop at a local desktop folder. In enterprise environments, corporate assets rarely live on individual workstations or in personal drive accounts. Technical specifications, design repositories, legal agreements, and operational policies reside in shared storage repositories designed for multi-user collaboration.

### Two Divergent Shared Storage Architectures

Organizations managing shared files typically balance two primary storage architectures, each with distinct technical constraints when accessed by AI agents:

1. **Google Workspace Shared Drives (Formerly Team Drives):** Unlike personal Google Drive accounts where files are owned by individual users, files in Shared Drives belong to the organization. Managing access involves domain-wide permission models, role-based controls, and specific API query parameters that determine whether an external tool can discover items in the drive.
2. **Network-Attached Storage and SMB/CIFS Shares:** On-premises file servers, network appliances, and storage area networks host petabytes of CAD drawings, build artifacts, financial ledgers, and video production media. These shares operate over network file protocols such as SMB and NFS, relying on operating system mounts and local area network connectivity.

### Why Agentic Workflows Require Shared Storage Access

Language models are transitioning from isolated chatbots into proactive team contributors. In tool-assisted workflows like Claude Code and Claude Desktop, an assistant requires direct access to team documentation to draft code, verify requirements, and validate system architecture:

* **Engineering Context in Claude Code:** When developers prompt Claude Code to implement an API route or refactor a microservice, the assistant needs access to architecture decision records, data models, and interface schemas stored in engineering team drives.
* **Operational Alignment in Claude Desktop:** Operations, product, and legal teams query Claude Desktop for policy interpretations, vendor contracts, and client deliverables that reside in shared department folders.
* **Cross-Functional Team Collaboration:** When human engineers and AI assistants collaborate within the same organizational context, isolating files on an individual laptop creates knowledge silos and version drift.

Attempting to solve this problem by manually downloading files or copying them into local project directories creates version fragmentation and breaks team coordination. Bridging Claude to team drives requires addressing the root API and network bottlenecks that cause standard connectors to fail.

## Why Native Connectors and Filesystem Mounts Fail on Shared Drives

Standard Claude Google Drive guides only address My Drive, leaving teams using Google Workspace Shared Drives unable to access their files. Understanding why native connectors fail requires examining how cloud storage APIs, desktop sync clients, and network protocols interact with language model reasoning loops.

### The Missing supportsAllDrives Flag in Google Drive API v3

The primary failure point when connecting Claude to Google Shared Drives is API parameter scoping. In the Google Drive API v3, file listing and search endpoints default to personal user scope.

When an application queries the `files.list` endpoint, it searches only the authenticated user's personal My Drive unless the client explicitly passes two required boolean parameters:

* `supportsAllDrives=true`: Informs the Google Drive API that the calling application is designed to handle items located in Shared Drives.
* `includeItemsFromAllDrives=true`: Specifies that the search response must include items originating from both personal drives and Shared Drives.

If a connector or custom script queries Google Drive without these parameters, the API completely omits files stored in Shared Drives from the result set. Direct file retrieval via `files.get` also returns an HTTP 404 Not Found error for Shared Drive files if `supportsAllDrives=true` is omitted, even when the user possesses full administrative permissions on the drive.

### Virtual File Stubs and the Google Docs Parsing Problem

Organizations frequently attempt to bypass API issues by mounting Google Drive locally using the Google Drive for Desktop application, then pointing Claude Desktop's local filesystem MCP server at the mounted drive. This approach fails immediately when reading native Google Workspace formats.

Google Drive for Desktop synchronizes native documents using virtual file stubs. Files ending in `.gdoc`, `.gsheet`, and `.gslides` on the local file system do not contain document text, markdown, or binary office structures. They are small JSON pointer records containing document identifiers and web links:

```json
{
  "url": "https://docs.google.com/document/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit",
  "doc_id": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
  "email": "engineer@company.com"
}
```

When Claude reads `system_architecture.gdoc` through a filesystem MCP server, the model receives only the JSON URL stub. Because Claude cannot execute a client-side browser session to render the web page from that stub, the assistant cannot read the underlying document content. Resolving the text requires authenticating against Google APIs, exporting the document to an intermediate format such as DOCX or plain text, and parsing the payload before passing it to the model.

### Context Window Limits and Google Drive API Throttling

Connecting Claude directly to raw cloud storage APIs exposes conversations to severe context and rate limit bottlenecks:

* **Context Window Exhaustion:** As documented by Anthropic, documents retrieved in Claude must fit within the conversation context window. Downloading an unindexed multi-page technical specification or an extensive spreadsheet into Claude dumps tens of thousands of tokens into active memory, driving up token costs and diluting attention, which leads to instruction forgetting.
* **API Rate Quotas:** The Google Drive API enforces per-user and per-project query limits. When Claude recursively walks folder hierarchies to locate a file, automated tool calls trigger HTTP 403 `userRateLimitExceeded` or HTTP 429 status codes, stalling the agent's execution loop.

### SMB Network Latency and Tool Timeouts

Attempting to connect Claude Desktop to an on-premises network drive (SMB or NFS) through a local filesystem MCP server introduces physical network bottlenecks:

1. **Synchronous Network Walks:** The standard `@modelcontextprotocol/server-filesystem` package executes synchronous filesystem checks on the host machine. Walking a directory tree containing 15,000 engineering assets across an SMB share over a corporate network or VPN takes dozens of seconds, regularly exceeding Claude Desktop's 60-second MCP tool call timeout.
2. **UNC Path Parsing Failures:** On Windows, raw Universal Naming Convention (UNC) paths like `\\server\share\docs` fail in standard Node.js path resolvers unless the administrator explicitly maps the share to a dedicated drive letter.
3. **Mount Instability:** Network mounts under `/Volumes` on macOS or `/mnt` on Linux disconnect when a laptop sleeps or when a VPN cycles, leaving Claude with broken file handles and `ENOENT` errors.

## Decoupling Shared Storage from Agent Context Retrieval

Solving the shared drive context challenge requires decoupling storage hosting from runtime retrieval. Instead of forcing Claude to crawl unindexed directory trees or pull heavy raw files over cloud storage APIs, engineering teams establish an indexed cloud workspace as an intermediary context layer.

### The Three-Step Workspace Bridge

Bridging Claude to Google Shared Drives and network storage operates through a clear three-step pipeline:

```
(Google Shared Drive or SMB Share)
               │
               ▼  Step 1: Cloud Ingestion & Scheduled Sync
    (Fast.io Cloud Workspace)
               │
               ▼  Step 2: Intelligence Mode Auto-Indexing (RAG)
  (Semantic Vector & Metadata Index)
               │
               ▼  Step 3: Remote MCP Querying (Streamable HTTP)
   (Claude Desktop / Claude Code)
```

1. **Maintain Source Storage in Existing Repositories:** Team documents, CAD archives, and operational policies remain stored in Google Shared Drives or SMB network shares under established enterprise permissions.
2. **Cloud Ingestion into an Intelligent Workspace:** Relevant project folders are imported into an intelligent [Fast.io workspace](/product/workspaces/). For organizations using Google Drive, Dropbox, Box, or OneDrive, Cloud Sync operates one-way or two-way, on a schedule or on demand, and is never continuous, live, or real-time. Network drive files can be imported or updated using the Fast.io CLI (`@vividengine/fastio-cli`) or workspace API.
3. **Automatic Intelligence Mode Indexing and Remote MCP Retrieval:** Once documents land in the workspace, Intelligence Mode automatically generates full-text and semantic vector indexes across supported formats, including PDF, DOCX, Markdown, CSV, and plain text. Claude connects to Fast.io's remote MCP server over Streamable HTTP at `https://mcp.fast.io/mcp/tools`. When Claude needs project context, it invokes the `storage` tool using the `search` action, retrieving concise, relevant excerpts with explicit document citations.

### Eliminating Context Bloat and Timeouts

Remote MCP workspace indexing eliminates file size and timeout errors when querying large shared media or engineering drives. Rather than transmitting a 40 MB PDF or scanning 10,000 network files during a conversation, Claude issues a semantic query against the pre-computed index. The workspace returns only the relevant paragraphs, reducing token consumption and preventing context dilution.

The connector comparison is published at https://fast.io/benchmarks/ where Fastio was measured the fastest and the lowest cost of the providers tested. By handling document parsing and vector indexing in the cloud, Claude retrieves precise context without downloading entire document corpuses or hitting local timeout thresholds. Teams can examine how workspace-level intelligence supports language models on the [Fast.io AI capabilities page](/product/ai/).

## How to Connect Claude Desktop and Claude Code via Remote Workspace MCP

Configuring Claude Desktop and Claude Code to query shared organizational files through Fast.io takes only a few minutes. Because Fast.io provides a hosted remote MCP server over Streamable HTTP, you do not need to compile local TypeScript scripts, run background daemons, or install local runtime dependencies. Setup steps and client documentation are available at [Fast.io documentation](https://mcp.fast.io/docs).

### Step 1: Configure Claude Desktop

In Claude (web, desktop, mobile): open Customize, then Connectors; add a custom connector and paste `https://mcp.fast.io/mcp/tools`; select Connect and sign in to Fastio in the window that opens; in a chat, turn Fastio on from the + menu under Connectors. Sign-in shows a Review Permissions screen where the person picks Read Only or Read & Write and which organizations and workspaces the connection can reach.

### Step 2: Configure Claude Code

For command-line development sessions using Claude Code, add the server directly from your terminal:

```bash
claude mcp add --transport http fastio-shared-storage https://mcp.fast.io/mcp/code
```

Then run `/mcp` inside Claude Code to sign in. A project `.mcp.json` entry needs `"type": "http"` and `"url"`:

```json
{
  "mcpServers": {
    "fastio-shared-storage": {
      "type": "http",
      "url": "https://mcp.fast.io/mcp/code"
    }
  }
}
```

### Step 3: Querying Shared Documents in Conversation

Once connected, Claude interacts with your workspace through the consolidated `storage` tool. Claude automatically chooses the appropriate action based on your prompt:

* **Semantic Search:** When you ask, "What are the authentication requirements in our engineering spec?", Claude invokes `storage` with `action: "search"`. The server queries the pre-computed semantic index and returns exact text passages alongside document citations.
* **Document Fetching:** When Claude needs to inspect an entire specific file, it invokes `storage` with `action: "fetch"` using the file ID returned during the search.
* **Structured Data Extraction with Metadata Views:** If your shared drive contains hundreds of invoices, vendor agreements, or engineering reports, teams can configure [Metadata Views](/product/document-data-extraction/). Metadata Views turn unstructured documents into a structured database by automatically extracting typed fields (dates, amounts, counterparties, or status codes) without manual OCR rules. Claude queries these extracted fields directly through MCP, allowing instant filtering across thousands of shared files.

## How to Mount Local SMB Network Shares for Claude Desktop

While indexed cloud workspaces provide the most reliable architecture for team drives, individual engineers sometimes require direct, local read and write access to an on-premises SMB network share during single-user coding sessions. For this specific scenario, Claude Desktop can connect to a local SMB share using the standard `@modelcontextprotocol/server-filesystem` package.

To prevent tool call timeouts and file lock errors, direct SMB access requires strict mount management and tight directory scoping.

### Step 1: Mount the SMB Share at the Operating System Level

Never attempt to pass raw network addresses or unmounted SMB URLs directly to Claude Desktop. Mount the share to a local path or drive letter first:

* **Windows (Drive Letter Mapping):** Map the SMB share to a persistent drive letter using Command Prompt or PowerShell:
 

```cmd
  net use Z: \\fileserver\engineering /persistent:yes
 

```
* **macOS (Volume Mount):** Mount the share using Finder (Go > Connect to Server) or terminal:
 

```bash
  mkdir -p /Volumes/engineering
  mount -t smbfs //user@fileserver/engineering /Volumes/engineering
 

```
* **Linux (CIFS Mount):** Mount the share into `/mnt` with persistent credentials:
 

```bash
  sudo mount -t cifs //fileserver/engineering /mnt/engineering -o credentials=/etc/cifs-credentials,uid=1000
 

```

### Step 2: Configure the Filesystem MCP Server

In `claude_desktop_config.json`, configure `@modelcontextprotocol/server-filesystem` to target a specific project folder rather than the root of the network drive:

```json
{
  "mcpServers": {
    "network-engineering-share": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Volumes/engineering/active-specs"
      ]
    }
  }
}
```

On Windows, use the mapped drive letter:

```json
{
  "mcpServers": {
    "network-engineering-share": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "Z:\active-specs"
      ]
    }
  }
}
```

### Critical Operational Constraints for Direct SMB Connections

Directly connecting Claude to an SMB share carries significant operational tradeoffs:

* **Scope Boundaries:** Pointing `@modelcontextprotocol/server-filesystem` at the root of a multi-terabyte network drive containing tens of thousands of files will freeze Claude Desktop. Node.js directory walks over SMB are synchronous and latency-sensitive. Restrict the configured path to the specific subdirectory containing your active task files.
* **Network Mount Drops:** If your computer disconnects from the office network or corporate VPN, the operating system mount drops. Claude Desktop will display tool call errors with `ENOENT` (No such file or directory) until the share is remounted and Claude Desktop is restarted.
* **Single-User Scope:** Direct SMB connections do not support shared semantic indexing across a team. Every developer's laptop must mount the network share independently, and Claude must re-read raw files across the network on every prompt.

Teams requiring shared access across multiple developers, remote collaborators, or autonomous agents should deploy dedicated [storage for agents](/storage-for-agents/) using indexed cloud workspaces.

## Governance, Advisory Locks, and Multi-Agent Coordination on Shared Storage

Connecting AI agents to organizational storage creates new governance requirements. When multiple humans and autonomous Claude sessions access the same shared repositories, organizations must enforce clear permission boundaries, track file modifications, and coordinate concurrent edits.

### Granular Permission Architecture

Fast.io provides granular access controls across organizational hierarchies:

* **Organization Level:** Administrators manage overall subscription seats, storage allowances, and top-level policies.
* **Workspace Level:** Separate workspaces isolate distinct projects, departments, or client matters. Claude credentials configured for an engineering workspace cannot access financial or human resources workspaces.
* **Folder and File Level:** Specific folders can be scoped for read-only access or restricted to designated collaborators.

### Managing Concurrent Writes with Advisory Locks

When multiple agents or human engineers collaborate within a shared workspace, uncoordinated writes risk creating conflicting versions. Fast.io provides advisory per-file lease locks through the MCP `storage` tool:

1. **Acquiring a Lock:** Before modifying a shared document, an agent invokes `storage` with `action: "lock-acquire"`.
2. **Heartbeating Leases:** The lock remains active as long as the holding agent heartbeats the lease through `action: "lock-status"`. If an agent finishes its task or disconnects, the lease automatically expires.
3. **Preserving History:** Advisory locks do not block emergency writes. If two collaborators submit concurrent updates, Fast.io's per-file version history saves every revision independently, allowing team members to inspect differences and restore prior versions without data loss.

### Observability with Append-Only Audit Logs and Activity Feeds

Enterprise file governance requires complete visibility into how AI models interact with corporate knowledge:

* **Detailed activity log:** Fast.io records every document creation, modification, download, and search query in a detailed activity log. Security administrators can verify which files Claude accessed during any specific conversation.
* **Workspace Activity Feed:** External automation scripts can subscribe to workspace events using WebSockets or an HTTP long-poll at `GET /current/activity/poll/{entity_id}?wait=95&lastactivity={timestamp}`. When an engineer uploads a new specification to the shared workspace, listening agents can react immediately to process updates.

### Pricing and Getting Started

Organizations evaluating shared storage for Claude can begin with a 14-day free trial on monthly plans, which requires a credit card.

| Plan Tier | Monthly Price | Included Storage | Workspaces | Monthly Credits |
|---|---|---|---|---|
| Starter | $9.99/mo | 250 GB | 5 | 100,000 |
| Business | $49.99/mo | 5 TB | 50 | 600,000 |
| Enterprise | $199.99/mo | 25 TB | 200 | 3,000,000 |

Annual plan options provide discounted billing across all subscription tiers. Storage beyond plan allowances is 1.5 cents per GB per month, and additional bandwidth is 4 cents per GB. Check the [Fast.io pricing page](/pricing/) to select the tier that fits your team's storage and agent coordination requirements.

## Frequently asked questions

### Can Claude Desktop access Google Shared Drives?

Claude Desktop cannot reliably access Google Shared Drives through standard personal connectors because the Google Drive API v3 defaults to personal My Drive queries unless explicit supportsAllDrives=true and includeItemsFromAllDrives=true flags are passed. At the same time, local filesystem connectors reading Google Drive for Desktop only see virtual .gdoc pointer stubs containing web URLs. Connecting Claude Desktop to an indexed Fast.io workspace via remote MCP provides full access to team drive files with semantic search and zero context bloat.

### Why can't Claude see files in my Google Workspace Team Drive?

Claude cannot see files in Google Workspace Team Drives (Shared Drives) when connectors omit the supportsAllDrives=true parameter required by Google Drive API v3. Without this parameter, API queries return results solely from personal My Drive storage, treating organizational Shared Drives as empty. Connecting your Google Drive assets through an indexed workspace bypasses these API omissions by surfacing files through pre-indexed MCP search.

### How do I connect Claude Code to an SMB network shared drive?

To connect Claude Code to an SMB network drive, mount the share to a local operating system path such as Z:\ on Windows or /Volumes/share on macOS, then configure @modelcontextprotocol/server-filesystem in .mcp.json scoped strictly to an active project folder. For multi-user teams or large archives where network latency causes tool timeouts, import files into an indexed Fast.io workspace and connect Claude Code via remote MCP.

### What is the difference between connecting Claude to My Drive versus a Shared Drive?

Connecting Claude to My Drive queries an individual user's personal storage root where files are individually owned. Connecting to a Shared Drive requires organizational permissions, domain-wide consent, and explicit API parameters that inform Google Drive that the caller supports team-owned drives. Shared Drives also frequently hold thousands of organizational documents, making unindexed API crawling susceptible to rate limits and context window exhaustion.

### How does workspace indexing prevent Claude context window limits and timeouts?

Workspace indexing processes files into full-text and vector embeddings in the cloud before queries arrive. When Claude searches for project specifications, the remote MCP server returns only the relevant excerpts and document citations instead of transmitting raw multi-megabyte PDFs or entire folder hierarchies over the connection. This eliminates network timeouts and preserves conversation context.

### Can Claude edit files directly on a network share or Google Shared Drive?

Direct file editing depends on the connector. Local filesystem MCP servers can write changes to mounted SMB shares if your user account has write permissions, though concurrent edits risk overwriting teammate changes. For cloud workspaces, Claude writes updates to the workspace where advisory per-file lease locks and version history preserve every revision.

## Sources

- [Google for Developers: Google Drive API v3 Reference (files.list)](https://developers.google.com/drive/api/v3/reference/files/list): The Google Drive API requires applications to declare shared drive support via the supportsAllDrives parameter.
- [Claude Help Center: Use Google Workspace connectors](https://support.claude.com/en/articles/10166901-use-google-workspace-connectors): Google Drive files retrieved in Claude must fit within the active conversation context window.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.