# Langflow OneDrive Integration: Visual RAG and Agent Workspaces

A Langflow OneDrive integration brings documents stored in Microsoft OneDrive into Langflow visual workflows for dynamic document retrieval. While direct Microsoft Graph API calls can hit memory limits and rate throttling when parsing Office files, connecting Langflow to an indexed Fastio workspace offloads chunking and vector search. Workspaces connect via remote Model Context Protocol (MCP), returning relevant passages with citations without polling entire directories.

Source: https://fast.io/resources/langflow-onedrive-integration/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-19

## Why Direct Graph API Connections Strain Langflow Ingestion Pipelines

When a Langflow visual pipeline attempts to extract text from multi-page PDFs and Office files by issuing direct Microsoft Graph API calls during flow execution, worker processes can stall or trigger out-of-memory errors. The architectural tension arises because Langflow is optimized for low-latency visual orchestration of embeddings and prompts, while raw document extraction from enterprise storage demands substantial memory overhead, recursive directory traversal, and persistent delta token management.

A Langflow OneDrive integration brings documents stored in Microsoft OneDrive into Langflow visual workflows for dynamic document retrieval. However, the mechanism used to connect the visual canvas to Microsoft storage determines whether retrieval completes within seconds or fails under operational rate limits and container memory caps.

### Enterprise Tenant Governance and Entra ID Permission Obstacles

Most deployment guides assume developers possess administrative control in Microsoft Entra ID. In corporate settings, standard team members cannot grant application-level permissions like `Files.Read.All` or `Sites.Read.All` to conversational agents or custom Python components. Securing tenant-wide administrator consent requires IT governance reviews and security audits that can delay team adoption by weeks.

Direct integrations also create account boundaries. The Microsoft Graph API distinguishes between personal Microsoft accounts and Microsoft 365 organizational accounts. Components configured for work drives fail when presented with personal consultant storage, while personal account tokens lack the permission scopes required to traverse team SharePoint libraries. Teams building multi-source retrieval pipelines have to handle both account types.

### Microsoft Graph API Rate Limits and HTTP 429 Throttling

When a Langflow agent traverses OneDrive folders via Microsoft Graph, every recursive directory scan, metadata fetch, and binary file download counts against request limits. Microsoft Graph enforces request limits per user and per tenant to maintain infrastructure stability. High-frequency queries trigger HTTP status code 429 (Too Many Requests), and SharePoint and OneDrive resources can also return HTTP 503 (Server Too Busy).

Every HTTP 429 response includes a `Retry-After` header requiring client applications to pause for a designated duration before resubmitting the request. Microsoft notes that Graph keeps logging resource usage while a client is throttled, so a Langflow custom component that retries immediately prolongs the throttling. In an interactive agent session, an extended delay causes the pipeline to abort execution or return a timeout error.

### Delta Query Management and State Loss in Stateless Flow Containers

Tracking document changes in OneDrive requires Microsoft Graph delta queries. Instead of enumerating an entire drive repeatedly, delta queries use an initial call to generate an `@odata.deltaLink` containing an opaque tracking token. Subsequent requests pass this token to retrieve only newly added, modified, or deleted files.

Langflow pipelines typically run inside containerized environments managed by Uvicorn and Gunicorn worker processes. Because visual flow executions are stateless by design, custom components lack a persistent database to store and rotate delta tokens across runs. When a worker process restarts or a new execution container spawns, the delta token is lost. The component is forced to initiate a full directory refetch, triggering Graph API rate limits and re-indexing unchanged documents.

Delta tokens can also expire if a sync interval exceeds service cache retention windows. When an expired token is submitted, Microsoft Graph responds with HTTP status code 410 (Gone) and an error code indicating that a resync is required. Without resilient token persistence and automated resync fallbacks, visual components crash unexpectedly during active user sessions.

### Container Memory Exhaustion When Parsing Office Documents

Langflow custom components executing raw Graph API calls face strict memory limits when parsing complex Office files. Unlike plain text files or raw API payloads, enterprise repositories contain Word documents (`.docx`), PowerPoint presentations (`.pptx`), and scanned PDF binders. Parsing these binaries requires dedicated Python libraries such as `pypdf` or `python-docx`.

When an agent flow downloads a large presentation or a lengthy scanned agreement into container memory, the Python worker must decompress the file, parse the XML hierarchy, extract text blocks, and generate chunks. Under concurrent query traffic, memory consumption multiplies rapidly. When a container exceeds its allocated RAM limit, the operating system kernel issues a `SIGKILL` signal to terminate the worker process, dropping active user sessions and corrupting flow state. Resolving these bottlenecks requires decoupling primary file storage from active visual inference.

## Architecting Visual RAG: Fastio Workspaces as the Intelligent Storage Substrate

Instead of forcing Langflow worker containers to download raw binaries and parse complex file formats over Microsoft Graph, teams place an intelligent workspace between Microsoft storage and the visual canvas. The organization retains its primary folders in Microsoft OneDrive, preserving established file structures, sharing rights, and desktop syncing habits.

Fastio Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Cloud Sync works with OneDrive for Business, and SharePoint document libraries are reached through the OneDrive connector. Synchronizing files into an intelligent workspace eliminates continuous Graph API polling and isolates visual agents from tenant rate limits.

### Decoupling Storage Ingestion from Visual Inference

Connecting Langflow to indexed Fastio workspaces offloads heavy document parsing and chunking from the agent container. When files sync into a [Fastio workspace](/product/workspaces/) with Intelligence Mode enabled, every document is indexed automatically as it arrives. Fastio combines keyword search, vector embeddings for semantic retrieval, and metadata-value filtering into an integrated hybrid search layer.

The ingestion engine processes PDFs, Microsoft Word documents, Excel workbooks, PowerPoint decks, text files, and scanned documentation. Because parsing and vector indexing occur in the background when files are added or updated, Langflow never pauses for document processing during an active conversation.

### Pre-Computed Hybrid Search and Page-Level Citations

Fastio provides a remote Model Context Protocol endpoint over Streamable HTTP at `https://mcp.fast.io/mcp/tools` for general agent runtimes and visual orchestrators. Langflow agents connect directly to this endpoint using the native `MCP Tools` component.

When a user asks a Langflow agent to analyze a policy document or locate an engineering specification, the agent calls the `search` action on the workspace. Fastio inspects the pre-computed hybrid index and returns only the exact paragraphs relevant to the query, accompanied by document citations and file metadata. Instead of streaming tens of megabytes over Microsoft Graph, Langflow receives focused text snippets, without touching tenant rate limits.

### Measured Connector Performance

When evaluating connector efficiency for enterprise storage backends, retrieval speed and API overhead dictate whether visual agents feel responsive or sluggish. 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 offloading file parsing and semantic indexing to an optimized workspace, Langflow agents retrieve verified facts without exhausting container memory or Microsoft 365 tenant budgets. Teams can explore how workspaces support agent collaboration through [Fastio AI capabilities](/product/ai/).

## How to Build a Langflow OneDrive Integration via Fastio Remote MCP

Setting up an automated bridge between Microsoft OneDrive and Langflow takes five straightforward steps. The architecture runs entirely cloud-to-cloud without local sync daemons, background terminal processes, or open inbound ports.

### Component Configuration Checklist

Use this checklist to verify your visual RAG pipeline configuration before deploying the flow to team members:

| Configuration Item | Setting | Purpose |
| :--- | :--- | :--- |
| **Workspace Intelligence** | Intelligence Mode: Active | Automatically generates full-text and semantic vector indexes for uploaded files. |
| **Cloud Sync Provider** | Microsoft OneDrive for Business | Connects cloud folders, and SharePoint libraries through the same connector, over OAuth. |
| **Sync Direction** | One-Way (Read-Only) or Two-Way | Controls whether Langflow can write generated summaries back to OneDrive. |
| **Sync Interval** | Scheduled or On-Demand | Avoids continuous Graph API polling and HTTP 429 rate penalties. |
| **Langflow Component** | `MCP Tools` component | Connects visual canvas to remote Model Context Protocol servers. |
| **Langflow Connection Type** | HTTP (the HTTP/SSE option in Langflow) | Connects to Fastio's remote server, which runs over Streamable HTTP. |
| **Endpoint URL** | `https://mcp.fast.io/mcp/tools` | Designated remote MCP tools address for general agent runtimes. |
| **Authentication Header** | `Authorization: Bearer <api key>` | Authenticates headless agent requests using a scoped Fastio API key. |

### 1. Create a Fastio Workspace with Intelligence Mode

Sign in to Fastio and create a workspace for the project, with a name that matches the project domain (for example, "Product Specifications & User Manuals").

In the workspace settings, confirm that Intelligence Mode is enabled. Intelligence Mode instructs the workspace to generate full-text search indexes and semantic vector embeddings automatically as files arrive.

### 2. Configure Cloud Sync for OneDrive and SharePoint

Fastio Cloud Sync supports one-way and two-way sync with OneDrive for Business, on a schedule or on demand:

* In the workspace, open Cloud Sync and add a connection.
* Choose Microsoft OneDrive as the provider.
* In the Microsoft sign-in window, sign in with your Microsoft 365 work account.
* Review the access Fastio requests and approve it. If your tenant requires administrator approval for third-party apps, an administrator may need to approve it first.

Select the specific OneDrive folder or SharePoint library containing the documents you wish to query. Configure the synchronization parameters:

* **Direction**: Select One-Way (OneDrive to Fastio) for read-only reference libraries, or Two-Way if you want Langflow agents to write generated documentation back to OneDrive.
* **Sync Schedule**: Set a recurring schedule, or run syncs on demand. Cloud Sync runs one-way or two-way, on a schedule or on demand, and is never continuous, live, or real-time. If you need newly saved OneDrive files sooner, run a sync on demand.

### 3. Add the MCP Tools Component to the Langflow Canvas

Register Fastio as an MCP server in Langflow, then place it on the canvas:

1. Open Settings, then MCP Servers, and select Add MCP Server (you can also start from MCP in the left sidebar).
2. Choose the HTTP connection type (labeled HTTP/SSE), name the server, and set the URL to `https://mcp.fast.io/mcp/tools`.
3. Under Headers, add the key `Authorization` with the value `Bearer <FASTIO_API_KEY>`.
4. Open your flow, drag the Fastio server from the MCP section of the sidebar onto the canvas as an `MCP Tools` component, and enable **Tool mode** in the component's header menu so connected agents can call the exposed actions.

Complete endpoint parameters and tool documentation are available in the [Fastio MCP setup guide](https://mcp.fast.io/docs) and the [Fastio MCP skill guide](https://mcp.fast.io/skill.md).

### 4. Wire the Toolset to the Langflow Agent Component

Drag an Agent component onto the canvas:

1. Connect the **Toolset** port of the `MCP Tools` component to the **Tools** port of the Agent component.
2. Choose your model provider and model in the Agent component's own settings.
3. Connect a Chat Input component to the Agent's input and a Chat Output component to the Agent's output.

When a user submits a query through the Chat Input, the Agent inspects the available tools from Fastio, selects the `search` action, passes the user's intent to the pre-indexed workspace, and receives relevant document excerpts with exact file references.

### 5. Custom Python Component for Direct Retrieval

For teams that prefer dedicated custom components on the Langflow canvas rather than the generic agent toolset, Langflow allows you to write custom Python components that query Fastio directly. The following implementation calls Fastio's REST search endpoint (`GET /current/workspace/{workspace_id}/storage/search/`) with the standard `requests` library. Intelligence Mode must be enabled on the workspace for semantic results:

```python
import os

import requests
from lfx.custom.custom_component.component import Component
from lfx.io import MessageTextInput, Output, StrInput
from lfx.schema import Data


class FastioWorkspaceRetriever(Component):
    display_name = "Fastio Workspace Retriever"
    description = "Searches indexed OneDrive documents in a Fastio workspace"
    icon = "folder-search"

inputs = [
        StrInput(name="workspace_id", display_name="Workspace ID"),
        MessageTextInput(name="query", display_name="Search Query"),
    ]
    outputs = [
        Output(name="results", display_name="Results", method="search_workspace"),
    ]

def search_workspace(self) -> Data:
        # The API key comes from the environment rather than the flow definition
        response = requests.get(
            f"https://api.fast.io/current/workspace/{self.workspace_id}/storage/search/",
            headers={"Authorization": f"Bearer {os.environ['FASTIO_API_KEY']}"},
            params={"search": self.query, "limit": 10},
            timeout=15,
        )
        if response.status_code != 200:
            return Data(data={"error": f"Search failed with status {response.status_code}"})
        passages = [
            {"text": hit.get("content"), "file": (hit.get("node") or {}).get("name")}
            for hit in response.json().get("results", [])
        ]
        return Data(data={"passages": passages, "source": "Fastio workspace"})
```

This custom component eliminates local document parsing, token tracking, and vector calculation. The Python worker simply receives pre-extracted text passages, keeping container RAM usage under control.

## Bi-Directional Writebacks, Version History, and Metadata Views

Many conversational setups treat cloud storage as a passive, read-only repository. While an assistant can inspect an existing contract or read a presentation, it cannot save refined drafts, compile structured tables, or file analytical reports back into cloud storage.

Fastio pairs conversational retrieval with writeback capabilities, structured document processing, and persistent workspace coordination.

### Bi-Directional Document Generation and Writebacks

When Langflow is connected with Read & Write permissions and two-way Cloud Sync is active, the visual pipeline acts as an active contributor. After an agent analyzes customer interviews, contract renewals, or survey responses, it writes a new markdown brief or CSV export directly into the workspace folder through Fastio's write tools (`upload_manage` for new files, `storage_manage` for folders, moves and locks).

On the next scheduled sync pass, Fastio transmits the newly created file back to Microsoft OneDrive. Team members viewing the folder in Windows File Explorer, macOS Finder, or the OneDrive mobile app find the generated document alongside their original project files.

### Data Protection with Per-File Version History and Advisory Leases

Automating document generation introduces the risk of unintentional overwrites or conflicting edits between people and agents. Fastio safeguards workspace integrity using two mechanisms:

* **Per-File Version History**: Every write, whether initiated by an agent tool call or a human upload, creates an incremental version. Fastio tracks the full version timeline, allowing team members to review previous states and restore earlier iterations at any point.
* **Advisory File Locks**: When an agent begins a multi-step compilation process, it acquires an advisory lease using `lock-acquire` on `storage_manage`, checks lease status with `lock-status` on `storage`, and releases the lease with `lock-release` on `storage_manage`. Advisory leases expire automatically if not heartbeated and do not block human writes. Concurrent human and agent updates both land safely into version history.

Every creation, modification, move, and deletion is recorded in a detailed activity log, providing visibility into workspace operations without logging read-only views or downloads.

### Extracting Tabular Databases with Metadata Views

OneDrive folders frequently house collections of semi-structured business files, including commercial agreements, property leases, rate sheets, and invoices. Answering operational queries across hundreds of files in chat can be slow and repetitive.

Fastio [Metadata Views](/product/document-data-extraction/) turn unstructured documents into a live, queryable database. Users describe the desired extraction schema in natural language (for example, "extract tenant name, commencement date, expiration date, base rent, and renewal terms").

Fastio designs a typed schema supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time formats. The system parses PDFs, Word documents, spreadsheets, presentations, and scanned pages without rigid templates or manual OCR rules. Langflow agents query the resulting structured view directly via MCP, filtering hundreds of records without reading entire document bodies into the visual flow.

### Persistent Context with Collaborative Notes

Complex analytical projects require shared notes that persist across individual flow executions. Fastio Collaborative Notes let humans and AI agents document shared instructions, pipeline configuration parameters, and prompt guidelines directly beside stored files.

Notes are indexed automatically for hybrid search. Fastio protects concurrent note edits through version-checked saves. If a user updates a note while Langflow is generating an addendum, Fastio detects the version change and prevents silent overwrites.

### Controlled External Sharing and Access Controls

Once Langflow produces research summaries or client deliverables, distributing them externally requires security controls. Sharing direct OneDrive links can expose internal folder structures and, depending on tenant policy, may require guest accounts.

Fastio replaces raw links with branded shares:

* **Send Shares**: Distribute project packages, contracts, or audits via branded links with password verification and expiration schedules. A share can disable file downloads to restrict recipients to in-browser viewing.
* **Receive Shares**: Collect client documents, onboarding materials, or financial records directly into a workspace folder without email attachment restrictions.
* **Exchange Shares**: Create two-way collaborative folders where clients can download deliverables and upload responses.

Permissions are managed at the organization, workspace, and share levels through member roles. Every workspace member accesses the entire workspace based on their assigned role. When specific folders must be shared externally, teams create dedicated shares. Teams evaluating storage infrastructure for automated assistants can review [storage for agents](/storage-for-agents/).

| Plan | Price | Included Seats | Storage | Workspaces | Monthly AI Credits |
| :--- | :--- | :--- | :--- | :--- | :--- |
| Starter | $9.99/mo | 3 seats | 250 GB | 5 workspaces | 100,000 credits |
| Business | $49.99/mo | 10 seats | 5 TB | 50 workspaces | 600,000 credits |
| Enterprise | $199.99/mo | 30 seats | 25 TB | 200 workspaces | 3,000,000 credits |

Monthly plans start with a 14-day free trial, which requires a credit card. Usage credits meter AI search, summarization, and metadata extraction, while storage capacity and user seats come included with each subscription plan.

## Troubleshooting Authentication, Delta Token Expiration, and Worker OOM Crashes

Connecting AI models to cloud storage can run into authentication blocks, API throttling, or worker memory crashes. Here is how to diagnose and resolve the most frequent integration issues.

### Resolving Microsoft Entra ID Consent Restrictions

If connecting a Microsoft connector displays an "Approval required" prompt, your tenant administrator has restricted user consent for third-party apps.

Fastio Cloud Sync signs in with delegated access, so it reaches only folders your own Microsoft account can already open, and your Langflow flow never needs its own Entra ID app registration or Graph permissions. Under a restrictive consent policy, an administrator may still need to approve the Fastio connection once. Langflow then accesses the indexed workspace via Fastio.

### Mitigating Microsoft Graph HTTP 429 Rate Limits

If direct Graph API queries fail or return sluggish responses during flow execution, review the API status code. Microsoft Graph returns HTTP 429 when request limits are exceeded.

When using Fastio Cloud Sync, you can avoid rate limits by adjusting your synchronization schedule. Rather than setting high-frequency sync intervals that trigger API spikes, set Cloud Sync to run every two or four hours, or use on-demand synchronization when documents are updated. If you need a freshly edited OneDrive document sooner, run a sync on demand from the workspace's Cloud Sync settings. The changed files are pulled into the workspace and indexed for search.

### Handling Delta Token Invalidation and Resync Cycles

When building custom ingestion components that interact with Microsoft Graph delta queries, tracking delta links is prone to cache invalidation. If a delta token expires or becomes invalid, Microsoft Graph responds with HTTP 410 (Gone), an error code such as `resyncChangesApplyDifferences` or `resyncChangesUploadDifferences`, and a Location header for a fresh enumeration.

When this occurs, custom components must catch the HTTP 410 response, discard the stored delta token, and initiate a clean baseline sync by querying the delta endpoint without a token parameter. Storing delta tokens in an external cache like Redis or a database prevents token loss across container worker restarts.

Alternatively, using Fastio Cloud Sync removes delta token handling from your visual flows entirely. Cloud Sync handles change detection between OneDrive and the workspace on each scheduled or on-demand run.

### Eliminating Worker SIGKILL and Memory Outages

If your Langflow container terminates abruptly with a `Worker was sent SIGKILL!` error, your Python workers have exceeded their container memory limits while parsing large files.

To prevent out-of-memory crashes:

1. Offload heavy parsing and chunking to Fastio by querying the pre-indexed MCP endpoint rather than downloading raw PDFs and Office documents into Langflow memory.
2. If you must process data locally inside custom components, initialize heavy models inside the `build()` method rather than the global script scope.
3. Explicitly trigger Python garbage collection (`import gc; gc.collect()`) after processing large text payloads.
4. Configure Gunicorn worker recycling in your deployment environment (for example, `--max-requests 150 --max-requests-jitter 30`) to reclaim fragmented RAM between flow executions.

### Handling OneDrive Files On-Demand Zero-Byte Stubs

If a file uploaded manually through the browser from a synced desktop folder arrives empty or unreadable, check whether it was an online-only placeholder.

Microsoft OneDrive's Files On-Demand feature replaces local files with zero-byte pointers on Windows and macOS, downloading file data only when opened locally. Because Fastio Cloud Sync connects directly to Microsoft cloud storage via OAuth, it bypasses local file system pointers entirely. If you upload manually through a browser from a synced desktop folder, right-click the folder in File Explorer or Finder, select "Always keep on this device," and wait for the green checkmark before initiating the transfer.

## Frequently asked questions

### How do I add OneDrive to a Langflow pipeline?

You can add OneDrive to a Langflow pipeline by syncing your OneDrive folders into a Fastio workspace and connecting Langflow via the Model Context Protocol. In Fastio, create a workspace with Intelligence Mode enabled and configure a OneDrive connection under Cloud Sync. In Langflow, add Fastio as an MCP server (URL `https://mcp.fast.io/mcp/tools`, with an `Authorization: Bearer` header carrying your Fastio API key), place its `MCP Tools` component on the canvas, enable Tool mode, and connect its Toolset port to an Agent component's Tools port to query indexed documents.

### Can Langflow agents read shared OneDrive folders?

Yes. With Fastio Cloud Sync you can connect OneDrive for Business folders, and SharePoint document libraries through the OneDrive connector, that your Microsoft account can access. Once synced into an intelligent workspace, Langflow agents can query those documents using semantic search without the flow itself holding Microsoft Graph permissions.

### What is the best way to index OneDrive documents in Langflow?

The most reliable way to index OneDrive documents is to offload ingestion and vectorization to an intelligent workspace rather than parsing files inside Langflow worker containers. Fastio Cloud Sync syncs documents on a schedule or on demand, while Intelligence Mode automatically generates full-text and semantic embeddings upon arrival. Langflow agents then retrieve pre-indexed text excerpts via remote MCP, avoiding Graph API rate limits and container memory crashes.

### Why do Langflow custom components crash when parsing OneDrive files?

Langflow custom components executing raw Graph API calls face strict memory limits when parsing complex Office files. Extracting text from multi-page PDFs, Word documents, and presentations inside Python worker memory causes rapid memory growth. When a container exceeds its RAM threshold, the host operating system terminates the process with a `SIGKILL` error, interrupting active user sessions.

### What happens if a Microsoft Graph delta token expires?

When a Microsoft Graph delta token expires, the driveItem delta API returns an HTTP 410 (Gone) status with an error code such as `resyncChangesApplyDifferences` and a Location header for a fresh enumeration. Custom ingestion components must catch this error, discard the invalid token, and re-enumerate the drive. With Fastio Cloud Sync, change detection happens on each scheduled or on-demand sync, so your flow does not manage delta tokens.

### Can Langflow write generated documents back to OneDrive?

Yes. When connected to a Fastio workspace with Read & Write permissions and two-way Cloud Sync active, a Langflow agent can save new markdown files, summaries, or analytical tables directly into the workspace through Fastio's write tools (`upload_manage` for new files, `storage_manage` for folders and moves). Fastio then synchronizes the generated files back to Microsoft OneDrive on the next sync pass.

### Does Fastio sync with Google Drive?

Yes. Fastio Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Any of these providers can also be used for one-time cloud imports.

### How does Fastio handle concurrent document edits from multiple agents?

Fastio protects concurrent document edits through per-file version history and advisory file locks. Every write creates an incremental version automatically, preserving previous revisions for auditability. Agents can acquire and release advisory leases via MCP actions (`lock-acquire` and `lock-release` on `storage_manage`) to signal active work without blocking human access.

## Sources

- [Microsoft Learn: Microsoft Graph throttling guidance](https://learn.microsoft.com/en-us/graph/throttling): Backing off requests using the specified delay is the fastest way to recover from Microsoft Graph throttling.
- [Langflow Documentation: MCP Tools](https://docs.langflow.org/mcp-tools): The MCP Tools component connects to a Model Context Protocol server and exposes its functions as tools for Langflow agents.

## 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.