# How to Index SharePoint Documents in LlamaIndex for AI Agents

LlamaIndex SharePoint integration connects LlamaIndex readers to Microsoft SharePoint document libraries, extracting and indexing corporate documents for generative AI retrieval. While native connectors allow direct retrieval via Microsoft Graph, large enterprise libraries frequently trigger throttling errors and high latency. This guide covers how to configure SharePointReader, handle Graph API limits, and connect agents to synchronized, pre-indexed workspaces over remote MCP.

Source: https://fast.io/resources/llamaindex-sharepoint/
Author: [Tom Langridge](https://fast.io/authors/tom-langridge/)
Last reviewed: 2026-09-12

## Connecting LlamaIndex to Enterprise SharePoint Libraries

When an autonomous AI agent attempts to ingest a corporate SharePoint library containing hundreds of nested documents, point-to-point API connectors break down under enterprise rate limits and payload transfer times. In production retrieval-augmented generation (RAG) architectures, naive readers pull entire file streams across the network before a model can evaluate document relevance. LlamaIndex SharePoint integration connects LlamaIndex readers to Microsoft SharePoint document libraries, extracting and indexing corporate documents for generative AI retrieval. While this direct link enables straightforward prototyping, running agentic pipelines across engineering and operations teams requires resolving operational hurdles in enterprise identity, Microsoft Graph quotas, and multi-format document parsing.

Most enterprise organizations already maintain thousands of business-critical assets across distributed storage systems, including Microsoft SharePoint, OneDrive, Dropbox, Box, and Google Drive. Corporate knowledge lives in architectural decision records, customer contracts, technical manuals, spreadsheets, and scanned vendor invoices. For engineering teams deploying AI agents, bringing this unstructured corporate knowledge into an LLM context window is essential for producing grounded, hallucination-free outputs. Engineers evaluating storage patterns can review [Fastio storage for agents](/storage-for-agents/) to understand how intelligent workspaces support autonomous pipelines.

LlamaIndex approaches this problem by providing specialized data connectors known as readers. In the native LlamaIndex ecosystem, these readers ingest files from external sources, parse raw text, package content into standardized Document objects, and split text into manageable nodes. From there, embedding models convert the text into high-dimensional vector representations, storing the resulting vectors in an index such as a VectorStoreIndex. When an agent receives a user prompt, it queries this index to retrieve top-k matching nodes and constructs an evidence-grounded answer.

However, the architecture chosen to bridge external files and agent context dictates system reliability. Developers face two fundamental implementation patterns:

1. Direct Graph API Ingestion: The application uses the native LlamaIndex SharePointReader to authenticate directly against Microsoft Graph, traverse remote document directories, download full file payloads during ingestion, and index documents locally or in a remote vector database.

2. Synchronized Workspace Retrieval: The team preserves SharePoint as the authoritative file store, selects OneDrive, then picks the SharePoint document library to synchronize selected folders into a dedicated cloud workspace such as Fastio on a controlled schedule or on demand, and exposes pre-indexed files to agents over the Model Context Protocol (MCP).

Understanding how the native reader operates, where its operational boundaries lie, and how pre-indexed storage architectures alleviate ingestion strain is critical for building resilient enterprise RAG systems.

## Configuring the Native LlamaIndex SharePointReader

The official integration package for connecting LlamaIndex to SharePoint is `llama-index-readers-microsoft-sharepoint`. This reader acts as an orchestration client over the Microsoft Graph REST API, handling OAuth authentication, folder discovery, and document downloads.

Setting up this integration requires three sequential phases: registering an enterprise application in Microsoft Entra ID, configuring scoped API permissions, and executing the ingestion script in Python.

### 1. Registering the Microsoft Entra ID Application

When configuring an autonomous agent or indexing script to run as a background service without an interactive user prompt, the application authenticates using OAuth 2.0 client credentials rather than delegated user credentials.

To register the application in the Microsoft Entra admin center:

1. Sign in to the Microsoft Entra admin center (`entra.microsoft.com`) using administrator credentials.
2. Navigate to Identity, select Applications, and click App registrations.
3. Click New registration. Provide a descriptive application name, such as `LlamaIndex-SharePoint-Ingestion`.
4. Under Supported account types, select Accounts in this organizational directory only (Single tenant). Leave the Redirect URI blank.
5. Click Register.
6. From the application Overview blade, copy and securely store the Application (client) ID and the Directory (tenant) ID GUIDs.
7. Navigate to Certificates & secrets, click New client secret, add a description, select an expiration period, and click Add. Immediately copy the secret string from the Value column.

### 2. Configuring Microsoft Graph Application Permissions

To configure the specific API permissions the reader requires to access SharePoint site collections and document libraries:

1. Navigate to API permissions and click Add a permission.
2. Select Microsoft Graph from the list, then select Application permissions.
3. Select the required permission scopes:
- `Files.Read.All`: Grants the application permission to read all files in all site collections.
- `Sites.Read.All`: Grants the application permission to discover and read SharePoint site collections and list metadata.
- `BrowserSiteLists.Read.All`: Grants permission to inspect document library lists.
4. Click Add permissions.
5. Critical step: Click Grant admin consent for your organization and confirm. Without explicit administrator consent, application permissions remain inactive, and Graph requests return HTTP 403 Forbidden errors.

For organizations enforcing strict least-privilege security policies, avoid `Sites.Read.All` and instead select `Sites.Selected`. This permission allows directory administrators to explicitly grant read or write permissions to only designated SharePoint site collections via Microsoft Graph API calls or PowerShell, preventing the ingestion agent from accessing sensitive HR, finance, or legal sites.

### 3. Implementing the Ingestion Script in Python

After Azure credentials are provisioned, configure the Python pipeline. Ensure that core LlamaIndex and the SharePoint reader integration are available in your environment:

```python
import os
from dotenv import load_dotenv
from llama_index.core import VectorStoreIndex
from llama_index.readers.microsoft_sharepoint import SharePointReader

load_dotenv()

CLIENT_ID = os.getenv("AZURE_CLIENT_ID")
CLIENT_SECRET = os.getenv("AZURE_CLIENT_SECRET")
TENANT_ID = os.getenv("AZURE_TENANT_ID")

reader = SharePointReader(
    client_id=CLIENT_ID,
    client_secret=CLIENT_SECRET,
    tenant_id=TENANT_ID
)

documents = reader.load_data(
    sharepoint_site_name="Engineering",
    sharepoint_folder_path="Specifications/2026",
    recursive=True
)

print(f"Successfully loaded {len(documents)} document nodes from SharePoint.")

index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

response = query_engine.query(
    "What are the network bandwidth requirements for edge node deployments?"
)
print(response)
```

If your Entra ID application uses the scoped `Sites.Selected` permission model, instantiate the reader by providing the SharePoint host name and site-relative URL rather than the bare site name:

```python
reader_scoped = SharePointReader(
    client_id=CLIENT_ID,
    client_secret=CLIENT_SECRET,
    tenant_id=TENANT_ID,
    sharepoint_host_name="acme.sharepoint.com",
    sharepoint_relative_url="sites/Engineering"
)

documents = reader_scoped.load_data(
    sharepoint_folder_path="Specifications/2026",
    recursive=True
)
```

This configuration executes direct HTTP queries against Microsoft Graph endpoints, retrieving files sequentially and generating document chunks for your vector index.

## Operational Bottlenecks: Microsoft Graph Throttling and Document Ingestion Latency

While standard tutorials present direct SharePoint ingestion as a simple three-line code snippet, production engineering teams face severe operational bottlenecks when loading enterprise-scale libraries. When LlamaIndex attempts to load hundreds of files from SharePoint over Microsoft Graph, teams encounter enterprise throttling, network latency, and memory bloat. Developers can consult the official [SharePoint Online throttling guidance](https://learn.microsoft.com/en-us/sharepoint/dev/general-development/how-to-avoid-getting-throttled-or-blocked-in-sharepoint-online) to inspect how Microsoft enforces request limits across tenants.

### Microsoft Graph API Throttling (HTTP 429)

Microsoft Graph is a multi-tenant platform designed to protect service health against traffic spikes. To ensure service stability, the service enforces strict rate limits across requests:

1. Delegated and Application Request Limits: The 10 requests per second limit in SharePoint Online applies specifically to delegated search queries. For directory traversal and file downloads, SharePoint Online enforces general user limits of 3,000 requests per 5 minutes alongside per-app resource-unit quotas.

2. The 429 Too Many Requests Response: When an application exceeds rate thresholds, Microsoft Graph returns an HTTP 429 response status accompanied by a `Retry-After` header. This header specifies the exact number of seconds the requesting client must pause before attempting another call.

3. Recursive Traversal Exhaustion: When `SharePointReader` runs with `recursive=True` over deep folder hierarchies, it makes separate Graph requests to enumerate drives, list children in every directory, fetch file metadata, and stream file contents. A directory containing deeply nested folders generates hundreds of discrete HTTP calls to enumerate files, fetch metadata, and stream file contents. If multiple developers or automated agents run ingestion jobs concurrently, the tenant quickly hits throttling thresholds.

If client code fails to implement backoff logic, subsequent requests fail immediately. If backoff logic is implemented, the ingestion process pauses for 10 to 60 seconds per throttling event, dragging total indexing runs from seconds into tens of minutes.

### Memory Overhead and Transfer Latency

The native SharePoint loaders download the entire raw byte stream of every document into the host machine's memory before parsing. If an engineering directory contains multi-page technical manuals, CAD specifications, and presentation slide decks, the host environment must allocate sufficient RAM to hold these large payloads.

In containerized or serverless runtime environments, such as AWS Lambda functions or Cloud Run microservices, downloading hundreds of megabytes of raw files triggers memory exhaustion crashes and exceeds maximum function execution timeouts. Furthermore, transferring full file payloads over the public internet consumes extensive bandwidth, creating high latency before the LLM can process a single query.

### Unreadable Scanned Documents and Missing Text Layers

A major point of failure in corporate SharePoint document repositories is the presence of image-only PDFs, scanned contracts, and legacy records lacking an embedded text layer.

Standard native readers rely on basic PDF parsers like `pypdf` or `pdfminer`. When these parsers encounter a scanned document without embedded font glyphs, they extract an empty string. The loader records a Document object with no text content, silently omitting critical facts from the resulting vector index. Unless developers build, maintain, and pay for an auxiliary OCR preprocessing pipeline, these documents remain invisible to downstream AI retrieval agents.

## Accelerating Retrieval with Synchronized Workspaces and Remote MCP

To eliminate the operational friction of direct Microsoft Graph ingestion, enterprise teams are separating corporate file storage from AI retrieval infrastructure. Instead of pointing an agent directly at Microsoft Graph or building custom OCR microservices, teams keep their source files in SharePoint while synchronizing selected folders into an intelligent Fastio workspace.

Fastio provides cloud workspaces designed specifically for agentic teams. Rather than downloading raw documents over fragile API connections during agent execution, Fastio connects to external storage providers, ingests files into an indexed workspace, and exposes search tools to AI agents via the Model Context Protocol (MCP). Technical details on endpoints and schema actions are documented in the [Fastio storage for agents](/storage-for-agents/) guide.

### Synchronized Storage Architecture

This architecture allows teams to maintain OneDrive, Box, or Dropbox as their corporate system of record, or reach SharePoint document libraries through the OneDrive connector. Folders are kept in sync, either one-way or two-way, on a recurring schedule or on demand. Because synchronization runs as a controlled background process rather than real-time polling, the system avoids Graph API rate limits and prevents synchronization storms. Note that while Dropbox, Box, and OneDrive folders support active sync (select OneDrive, then pick the SharePoint document library), Google Drive currently supports direct import with sync coming soon.

Once documents land in the workspace, Fastio's built-in Intelligence Mode indexes them automatically. Universal parsing processes PDFs, Word documents, spreadsheets, presentations, and scanned pages without requiring manual OCR configuration or external embedding pipelines. File contents and metadata are indexed for hybrid search, combining exact full-text keyword matching with semantic vector retrieval.

When structured document extraction is needed, [Metadata Views](/product/document-data-extraction/) allow teams to define typed extraction schemas in plain English. AI models automatically populate structured tables with fields such as contract dates, counterparties, totals, and renewal terms, allowing agents to query documents by exact metadata values.

### The Fast.io Remote MCP Server

The Fastio platform hosts a remote Model Context Protocol server over Streamable HTTP at `https://mcp.fast.io/mcp` (and `https://mcp.fast.io/mcp/key` for API bearer authentication), alongside legacy SSE at `https://mcp.fast.io/sse`. Because the server is hosted remotely, developers do not need to install local node daemons, manage local background processes, or configure complex Azure middleware.

Agents connect to the remote MCP server and query pre-indexed workspace content. Instead of pulling full documents across the network, the agent issues semantic and keyword search tool calls, receiving concise, citation-backed excerpts directly in its context window.

### Empirical Benchmark Evidence

The operational divergence between direct cloud storage connectors and indexed workspaces is documented in empirical testing. At [Fast.io Benchmarks](https://fast.io/benchmarks/), researchers evaluated the performance of an autonomous agent completing a multi-document audit across 211 files stored in different cloud providers.

The published testing methodology is strictly controlled:

"Every session ran in Claude in Cowork, the desktop app, with claude-opus-5 as the main agent. The published figures come from 15 fresh sessions on 9 September 2026, one per provider per test. Each test was fired as one wave, with the five providers started within about fifteen seconds of each other. The prompt text was identical per test except for the sentence naming the storage location. Session event logs were pulled from the code-sessions API and scored against the corpus answer key. Only the storage connector varied between sessions."

The multi-document audit required the agent to examine agreements, statements of work, invoices, and credit memos across legal and finance folders to build a complete customer profile. The results demonstrate the efficiency gap between the native OneDrive connector in Claude Cowork and indexed workspaces:

| Benchmark Metric | Native OneDrive Connector in Claude Cowork | Fastio Storage Workspace | Performance Differential |
|---|---|---|---|
| Wall-Clock Time (211 files) | 468.3s (7m 48s) | 170.0s (2m 50s) | 64% faster retrieval |
| Connector Invocations | 119 calls | 29 calls | 76% fewer calls |
| Input Tokens Consumed | 5,112,389 tokens | 2,366,163 tokens | 54% fewer tokens |
| Task Execution Cost | $4.83 | $3.06 | 37% lower task cost |
| Ground-Truth Facts Reported | 11 of 12 facts | 11 of 12 facts | Fact parity |
| Planted Traps Handled | 3 of 5 traps | 5 of 5 traps | Complete trap handling |
| Unreadable Documents | 2 (incl. credit memo) | 0 | Zero unreadable files |

In benchmark runs, the native OneDrive connector required 7 minutes and 48 seconds across 119 tool calls, reported 11 of 12 ground-truth facts, handled 3 of 5 planted verification traps, and left 2 unreadable documents (including the credit memo).

In contrast, Fastio completed the identical multi-document audit in 2 minutes and 50 seconds through a consolidated MCP toolset with zero unreadable files. By querying indexed files through remote MCP, the agent bypassed Microsoft Graph rate limits, substantially reduced input token consumption, and produced verified answers in less than half the time.

## Step-by-Step Implementation: Connecting LlamaIndex to Fastio via Remote MCP

Configuring a LlamaIndex agent to query SharePoint documents through a synchronized Fastio workspace eliminates client-side Graph rate limits and reduces code complexity. Follow this step-by-step walkthrough to set up synchronization and connect your agent via remote MCP.

### 1. Scope the Target SharePoint Document Library

To begin, identify the specific SharePoint document library or subfolder required for your agent's task. Rather than synchronizing an entire corporate intranet, target specific folders such as technical specifications, vendor agreements, or operational guides. Scoping folders improves organization, speeds up background processing, and establishes clear access boundaries.

### 2. Configure Cloud Synchronization in Fast.io

In the Fastio web console, create or open your target workspace and configure the storage sync:

1. From the workspace settings, select Cloud Sync.
2. Select OneDrive, then pick the SharePoint document library.
3. Authenticate with your Microsoft 365 credentials using standard OAuth.
4. Choose the specific site collection and folder identified in Step 1.
5. Select your synchronization direction: one-way sync to mirror SharePoint into Fastio as a read-only index, or two-way sync if agents will generate reports and write deliverables back to SharePoint.
6. Set your synchronization schedule, such as an hourly recurring sync or on-demand manual trigger.

### 3. Verify Background Indexing and Intelligence Mode

After synchronization initiates, Fastio ingests documents in the background. Intelligence Mode automatically parses all file types, generates semantic vector embeddings, and builds full-text search indexes. Scanned PDFs and image assets are parsed automatically, ensuring zero unreadable documents.

### 4. Provision Scoped Fastio API Credentials

To enable agent access:

1. Navigate to your Fastio organization settings and open Developer Settings.
2. Generate a new scoped API key with read permissions for the target workspace.
3. Securely store the API key in your agent environment as `FASTIO_API_KEY`.

### 5. Attach Remote Fast.io MCP Tools to a LlamaIndex Agent

The LlamaIndex framework interacts with Fastio's remote Model Context Protocol endpoint using standard HTTP tool adapters. Fastio exposes its remote Streamable HTTP endpoint at `https://mcp.fast.io/mcp/key`, which authenticates using standard Bearer tokens.

Here is a complete Python implementation connecting a LlamaIndex ReAct agent to the Fastio MCP endpoint:

```python
import os
import httpx
from dotenv import load_dotenv
from llama_index.core.agent import ReActAgent
from llama_index.core.tools import FunctionTool
from llama_index.llms.openai import OpenAI

load_dotenv()

FASTIO_API_KEY = os.getenv("FASTIO_API_KEY")
WORKSPACE_ID = os.getenv("FASTIO_WORKSPACE_ID")
MCP_ENDPOINT = "https://mcp.fast.io/mcp/key"

def search_workspace_documents(query: str) -> str:
    headers = {
        "Authorization": f"Bearer {FASTIO_API_KEY}",
        "Content-Type": "application/json"
    }
    
    # Calls the Fastio storage search tool (see mcp.fast.io/skill.md)
    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "storage",
            "arguments": {
                "action": "search",
                "profile_type": "workspace",
                "profile_id": WORKSPACE_ID,
                "query": query
            }
        }
    }
    
    with httpx.Client(timeout=30.0) as client:
        response = client.post(MCP_ENDPOINT, headers=headers, json=payload)
        response.raise_for_status()
        data = response.json()
        
        if "error" in data:
            return f"Fastio MCP Error: {data['error'].get('message', 'Unknown error')}"
            
        result = data.get("result", {})
        return str(result.get("content", "No matching passages found."))

fastio_tool = FunctionTool.from_defaults(
    fn=search_workspace_documents,
    name="search_sharepoint_workspace",
    description="Searches pre-indexed SharePoint files using the Fastio storage search tool (see mcp.fast.io/skill.md)."
)

llm = OpenAI(model="gpt-4o")
agent = ReActAgent.from_tools([fastio_tool], llm=llm, verbose=True)

response = agent.chat(
    "Check our synchronized SharePoint library and summarize the payment terms in the Bexley agreement."
)
print(response)
```

In this architecture, the agent never makes direct calls to Microsoft Graph during query execution. It calls the remote MCP tool, queries the pre-computed index, and receives concise text passages with document citations. This setup completely bypasses Graph API throttling and eliminates local file download overhead.

## Architectural Decision Guide: Direct Graph Readers versus Pre-Indexed Workspaces

When choosing between the native LlamaIndex SharePointReader and a synchronized workspace architecture, teams evaluate corpus size, team concurrency, and document complexity. Both approaches serve distinct technical requirements.

### Direct Ingestion with Native SharePoint Readers

The native SharePointReader connector is suitable for:

- Small, Static Document Libraries: If your repository contains a modest number of files that update infrequently, sequential ingestion over Microsoft Graph executes without triggering rate limits.
- Single-Tenant Internal Scripts: When an engineer runs an ad-hoc local script or experimental evaluation, managing direct Entra ID credentials in a local virtual environment is straightforward.
- Purely Text-Based File Repositories: If all documents are cleanly formatted Markdown, plain text, or standard Word files without scanned images or complex layouts, basic Python extractors can parse the text reliably.

### Synchronized Workspaces Over Remote MCP

A synchronized workspace model is recommended for:

- Large Enterprise Repositories: When libraries contain hundreds or thousands of files, scheduled synchronization decouples data ingestion from agent queries, preventing HTTP 429 throttling.
- Multi-Agent and Concurrent Workflows: In team deployments where multiple agents, CI/CD pipelines, or developers query documentation concurrently, a centralized MCP endpoint provides consistent, low-latency search without multiplying Graph API calls.
- Multi-Cloud Storage Environments: Many modern enterprises distribute documentation across multiple providers, storing project specs in OneDrive and SharePoint, brand media in Box, and contracts in Dropbox. Fastio allows teams to synchronize folders from Box, Dropbox, and OneDrive (select OneDrive, then pick the SharePoint document library) into a single workspace, providing agents with a single unified search endpoint.
- Complex and Scanned Documents: In environments containing scanned invoices, legal contracts, or non-text PDFs, Fastio's automated universal parsing ensures complete document visibility with zero unreadable files.
- Structured Extraction Needs: When business workflows require converting documents into queryable tables, Fastio's Metadata Views automatically extract typed schema columns without manual data entry.

### Operational Governance and Chain of Custody

For enterprise deployments, governance mechanisms are required to track document lineage and access. Fastio maintains an append-only, immutable audit log that records every file operation, member access, synchronization event, and AI interaction. Granular permissions can be configured across organizations, workspaces, folders, and individual files.

Furthermore, every file in Fastio maintains complete per-file version history. When two-way synchronization is active and agents write documentation, notes, or code deliverables back to the workspace, prior versions remain fully restorable.

For teams planning their production architecture, every organization starts with a 14-day free trial, which requires a credit card. Teams evaluating [Fastio pricing and plans](/pricing/) can choose Starter at `$29/mo`, Business at `$99/mo`, or Growth at `$299/mo`, providing scalable cloud storage, team seats, and credit allowances for intelligent agent workflows.

## Frequently asked questions

### How do I connect LlamaIndex to Microsoft SharePoint?

You can connect LlamaIndex to SharePoint using the native SharePointReader from the llama-index-readers-microsoft-sharepoint package. This requires an Azure Entra ID app registration with client credentials and Microsoft Graph application permissions (Sites.Read.All and Files.Read.All). Alternatively, you can synchronize SharePoint folders into an intelligent Fastio workspace and connect LlamaIndex agents over the remote Model Context Protocol (MCP) server.

### What Microsoft Graph permissions are required for LlamaIndex SharePointReader?

LlamaIndex SharePointReader requires Microsoft Graph application permissions including Sites.Read.All (or Sites.Selected for scoped access), Files.Read.All, and BrowserSiteLists.Read.All. An Azure directory administrator must grant tenant-wide admin consent for these permissions before the reader can access files.

### How do I index large SharePoint document libraries in LlamaIndex without running into API rate limits?

To prevent Microsoft Graph HTTP 429 throttling when indexing large libraries, synchronize your SharePoint folders into an intelligent Fastio workspace on a recurring schedule or on demand. Fastio pre-indexes file contents and exposes hybrid semantic search over remote MCP, allowing LlamaIndex agents to query targeted passages instead of downloading entire folders across Graph API.

### Can LlamaIndex write modified documents back to SharePoint?

Native LlamaIndex SharePoint readers are strictly read-only and cannot write or update files in SharePoint. However, when using Fastio workspaces configured with two-way cloud synchronization, agents connecting via MCP can write new documents, update files, or edit Collaborative Notes, and the workspace synchronizes changes back to SharePoint on schedule.

### What causes unreadable documents during SharePoint indexing?

Unreadable documents typically occur when SharePoint libraries contain image-only scanned PDFs, credit memos, or receipts that lack an embedded font text layer. Native readers without built-in OCR fail to extract text from these files. Fastio resolves this through automated universal parsing in Intelligence Mode, converting scanned documents into searchable text with zero unreadable files.

### How does Fast.io handle multi-cloud storage alongside SharePoint?

Fastio supports multi-cloud synchronization across OneDrive, Box, and Dropbox (select OneDrive, then pick the SharePoint document library), with Google Drive supporting import today and sync coming soon. Teams can synchronize folders from multiple providers into the same intelligent workspace, enabling LlamaIndex agents to search across corporate data repositories through a single unified MCP endpoint.

## Sources

- [Microsoft Learn: How to avoid getting throttled or blocked in SharePoint Online](https://learn.microsoft.com/en-us/sharepoint/dev/general-development/how-to-avoid-getting-throttled-or-blocked-in-sharepoint-online) — SharePoint Online throttles delegated search requests exceeding 10 requests per second per user.

## 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 at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.