# LangChain SharePoint Integration: How to Query Enterprise Documents

A LangChain SharePoint integration connects autonomous agents and retrieval chains to Microsoft SharePoint libraries, enabling conversational search across institutional document repositories. Directly traversing Microsoft Graph triggers HTTP 429 throttling and latency across deep folder trees. Synchronizing SharePoint folders into an intelligent Fast.io workspace gives LangChain agents pre-indexed search via remote MCP without downloading raw files.

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

## Why LangChain Traversal Breaks on Enterprise SharePoint

When an autonomous LangChain retrieval chain traverses an enterprise SharePoint document library file by file over Microsoft Graph, directory depth and API throttling turn an interactive assistant into a multi-minute bottleneck. In production question-answering systems and retrieval-augmented generation (RAG) architectures, fetching raw file payloads across the network to inspect document relevance introduces severe latency and runtime fragility. A LangChain SharePoint integration connects autonomous agents and retrieval chains to Microsoft SharePoint libraries, enabling conversational search across institutional document repositories. While spinning up a basic prototype using direct REST queries takes only an afternoon, maintaining dependable agent workflows across enterprise teams requires resolving complex hurdles in Microsoft Entra identity, Graph rate controls, and multi-format document extraction.

Most modern businesses store their operational knowledge across mixed cloud storage repositories, including Microsoft SharePoint, OneDrive, Google Drive, Box, and Dropbox. Critical organizational intelligence remains distributed throughout technical architecture reviews, vendor contracts, statements of work, executive briefings, and financial spreadsheets. For engineers developing AI agents with LangChain, bridging these scattered repositories into LLM context windows is essential for delivering grounded, factual responses. Developers evaluating storage patterns can explore [Fast.io storage for agents](/storage-for-agents/) to examine how intelligent workspaces support autonomous pipelines.

In the LangChain framework, external data ingestion flows through modular document loaders. In standard RAG pipelines, loaders fetch file streams from remote sources, package the extracted text and metadata into standardized LangChain `Document` objects, and pass them down to text splitters such as `RecursiveCharacterTextSplitter`. Downstream embedding models convert these text chunks into vector representations stored in systems like Chroma, FAISS, or PGVector. When an agent or end user submits an inquiry, a retriever pulls top-k matching passages to construct an evidence-grounded prompt.

However, the underlying data integration layer dictates whether an agent functions smoothly or fails under load. Engineering teams typically evaluate two distinct integration pathways:

1. Direct Graph API Ingestion: The application uses LangChain's community `SharePointLoader` 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 organization keeps OneDrive, Box, or Dropbox as the authoritative storage repository (reaching SharePoint document libraries through the OneDrive connector), synchronizes selected folders into an intelligent Fast.io workspace on a recurring schedule or on demand, and connects LangChain agents to pre-indexed search tools over the remote Model Context Protocol (MCP).

Understanding how these approaches differ in identity setup, API quotas, latency profiles, and document coverage is necessary for deploying enterprise-ready AI applications.

## How to Configure LangChain SharePointLoader via Microsoft Graph

The default community package for connecting LangChain to Microsoft 365 storage is `SharePointLoader`, provided in `langchain-community`. This loader manages communication with Microsoft Graph endpoints, handling OAuth token exchange, directory traversal, and document payload extraction.

Establishing a working ingestion pipeline requires registering an enterprise application in Microsoft Entra ID, assigning appropriate permission scopes, and writing the Python execution script.

### 1. Registering the Microsoft Entra ID Application

Unattended background ingestion jobs and automated agents cannot rely on interactive web logins. Instead, they require OAuth 2.0 client credentials authentication using an Entra ID application registration.

To create the application in the Microsoft Entra admin center:

1. Sign in to the Microsoft Entra portal (`entra.microsoft.com`) with directory administrator privileges.
2. In the left navigation menu, navigate to Identity, expand Applications, and select App registrations.
3. Select New registration. Enter an identifying name, such as `LangChain-SharePoint-Pipeline`.
4. In the Supported account types section, choose Accounts in this organizational directory only (Single tenant).
5. Leave the Redirect URI field empty for server-side background processes.
6. Click Register to create the application record.
7. On the application Overview blade, copy the Application (client) ID and Directory (tenant) ID values for your environment configuration.
8. Open Certificates & secrets, select New client secret, provide an expiration timeframe, and select Add. Copy the generated secret string immediately from the Value field, as Entra ID masks this token upon page navigation.

### 2. Granting Microsoft Graph Scopes and Administrator Consent

Your application registration must hold explicit permissions to inspect SharePoint site hierarchies and read document contents:

1. In your application dashboard, select API permissions from the sidebar, then select Add a permission.
2. Choose Microsoft Graph from the list of Microsoft APIs, then select Application permissions.
3. Search for and check the following permission scopes:
- `Files.Read.All`: Grants the application read access to all document libraries across all sites.
- `Sites.Read.All`: Grants permission to browse site collections and retrieve document library identifiers.
4. Click Add permissions.
5. Select Grant admin consent for your organization and confirm the prompt. Without tenant-level administrator approval, all downstream Graph requests will fail with an HTTP 403 Forbidden status code.

For security teams enforcing restricted access policies, replace `Sites.Read.All` with the narrower `Sites.Selected` permission. This requires an administrator to explicitly grant access to specific SharePoint site collections via PowerShell or Graph API commands, preventing the ingestion agent from viewing confidential corporate sites.

### 3. Locating the Document Library Identifier

Rather than accepting human-readable site URLs, `SharePointLoader` requires the underlying `document_library_id` GUID. You can retrieve this identifier using Microsoft Graph Explorer:

1. Navigate to the Graph Explorer interface (`developer.microsoft.com/graph/graph-explorer`).
2. Retrieve your target site ID by querying: `GET https://graph.microsoft.com/v1.0/sites/{tenant-domain}:/sites/{site-name}`.
3. List all document libraries within that site: `GET https://graph.microsoft.com/v1.0/sites/{site-id}/drives`.
4. In the returned JSON payload, locate the relevant drive object and record its `id` string.

### 4. Implementing the Ingestion Chain in Python

With credentials established, assemble the LangChain ingestion script. Ensure that necessary packages are installed in your environment:

```python
import os
from dotenv import load_dotenv
from langchain_community.document_loaders import SharePointLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate

load_dotenv()

client_id = os.getenv("AZURE_CLIENT_ID")
client_secret = os.getenv("AZURE_CLIENT_SECRET")
tenant_id = os.getenv("AZURE_TENANT_ID")
library_id = os.getenv("SHAREPOINT_LIBRARY_ID")

loader = SharePointLoader(
    document_library_id=library_id,
    folder_path="Operations/SOPs/2026",
    load_extended_metadata=True,
    recursive=True
)

raw_docs = loader.load()
print(f"Retrieved {len(raw_docs)} documents from SharePoint.")

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=150
)
split_docs = text_splitter.split_documents(raw_docs)

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = Chroma.from_documents(split_docs, embeddings)
retriever = vector_store.as_retriever(search_kwargs={"k": 4})

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer the inquiry using only the provided context snippets: {context}"),
    ("human", "{input}")
])

llm = ChatOpenAI(model="gpt-4o", temperature=0)
doc_chain = create_stuff_documents_chain(llm, prompt)
qa_chain = create_retrieval_chain(retriever, doc_chain)

result = qa_chain.invoke({
    "input": "What are the escalation procedures for unexpected system downtime?"
})
print(result["answer"])
```

While this implementation functions for small directories, invoking `loader.load()` buffers all extracted `Document` objects in system RAM simultaneously. On large enterprise repositories, this triggers memory bloat and API timeout errors.

## Operational Bottlenecks: Graph API Throttling, Latency, and Unreadable PDFs

Running direct SharePoint ingestion within continuous integration jobs, scheduled agent tasks, or production user workflows reveals significant infrastructure friction. Connecting LangChain directly to Microsoft Graph introduces rate limiting, network transfer delays, and document extraction failures that generic tutorials rarely acknowledge. Teams can review 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 Microsoft's service protection policies.

### Microsoft Graph API Throttling (HTTP 429)

Microsoft Graph protects multi-tenant cloud infrastructure by enforcing strict request limits. When an application initiates an excessive volume of requests within a short timeframe, the platform throttles the client:

1. Quota Boundaries: SharePoint Online applies aggressive throttling controls to protect backend resources. For search-oriented operations, SharePoint Online throttles delegated user requests that exceed 10 requests per second per user. Application-level background scripts share tenant-level resource pools that throttle traffic when concurrent queries surge.

2. Handling HTTP 429 Responses: When an application trips rate thresholds, Graph endpoints reject subsequent requests with an HTTP 429 Too Many Requests status code and provide a `Retry-After` response header indicating how many seconds the script must wait before retrying.

3. The Traversal Multiplier: When `SharePointLoader` runs with `recursive=True` across nested folder structures, it does not issue a single bulk query. Instead, it issues separate REST requests to enumerate folder contents, retrieve file metadata, inspect item permissions, and download binary payloads. A folder tree containing 500 files can trigger thousands of discrete HTTP round-trips. If multiple developers or automated agents run ingestion jobs concurrently, the tenant quickly hits throttling thresholds.

Without dependable exponential backoff handling, ingestion jobs crash immediately. Even with backoff algorithms implemented, repeated 30-to-60-second backoff delays cause ingestion runtimes to expand from seconds into tens of minutes.

### Memory Spikes and Network Latency in Serverless Runtimes

Standard LangChain document loaders download the full binary stream of each file to the host machine before executing text parsing. If a document library holds high-resolution presentation decks, multi-page technical manuals, or dense financial audits, the host runtime must allocate gigabytes of memory to process the queue.

In ephemeral serverless environments like AWS Lambda, Google Cloud Run, or lightweight Docker containers, loading full document payloads frequently triggers out-of-memory (OOM) fatal crashes and exceeds maximum execution timeouts. Transmitting unindexed files across the public internet also introduces severe network latency before the agent can even begin semantic evaluation.

### Scanned Documents and Missing Text Layers

Corporate SharePoint libraries routinely hold image-only PDFs, legacy scanned contracts, and signed purchase agreements lacking embedded digital text layers.

Native Python PDF utilities such as `pypdf` parse only embedded character streams. When encountering an image-only scanned document, these parsers extract an empty string. The loader quietly generates an empty `Document` object, omitting key contractual clauses from the downstream vector store. Unless developers build, maintain, and pay for an auxiliary OCR preprocessing pipeline, these documents remain invisible to downstream AI retrieval agents.

### Administrative Drift and Secret Expiration

Relying on direct Entra ID application registrations creates ongoing operational maintenance. Enterprise credential policies typically mandate client secret expiration every 90 days. When an operational secret expires without automated rotation, all downstream LangChain agents abruptly halt. Furthermore, as SharePoint site owners reorganize internal folders and alter site permissions, hardcoded library GUIDs break without warning.

## Accelerating LangChain Retrieval with Synchronized Workspaces and Remote MCP

To bypass the latency, throttling, and maintenance hurdles of direct Graph API ingestion, forward-thinking software teams decouple corporate file storage from AI retrieval infrastructure. Instead of pointing LangChain chains directly at Microsoft Graph or managing custom vector pipelines, organizations preserve SharePoint as their authoritative document archive while syncing relevant directories into an intelligent Fast.io workspace.

Fast.io delivers persistent cloud workspaces engineered specifically for autonomous agents and collaborative teams. Rather than pulling full document payloads over fragile API connections during chain execution, Fast.io connects directly 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 [Fast.io storage for agents](/storage-for-agents/) guide.

### Decoupled Storage Synchronization Under this architecture, your enterprise retains OneDrive, Box, or Dropbox as its primary system of record (reaching SharePoint document libraries by selecting OneDrive, then picking the library). Selected folders sync into a Fast.io workspace, either one-way to establish a read-only retrieval index or two-way to allow agents to save generated summaries and reports back to the connected library. Synchronization runs on a recurring schedule or on demand rather than through real-time polling, preventing Graph API rate exhaustion and eliminating synchronization storms. Note that while Dropbox, Box, and OneDrive folders support active sync, Google Drive currently supports direct import with sync coming soon.

As documents arrive in the workspace, Fast.io's Intelligence Mode automatically extracts and indexes content. Universal parsing handles 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 workflows require structured data extraction rather than conversational search, [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.

### Hosted Remote MCP Architecture

The Fast.io 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 background processes, or configure complex Azure middleware.

LangChain agents connect to the remote MCP server using lightweight tool wrappers. Instead of transferring full documents across the network, the agent executes targeted search queries against the pre-computed index, receiving concise, citation-backed excerpts directly in its context window.

### Standardized Benchmark Evidence

The efficiency divergence between querying raw cloud storage connectors and searching an indexed workspace 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 benchmark required an agent to examine customer contracts, amendments, invoices, and payment confirmations across legal and finance folders to compile a comprehensive profile. The recorded metrics demonstrate the substantial performance gap between direct Microsoft storage connectors and indexed workspaces:

| Evaluation Metric | Native OneDrive Connector (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 Extracted | 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 in Claude Cowork required 7 minutes and 48 seconds across 119 tool calls, reporting 11 facts, handling 3 traps, and leaving 2 files unreadable (including the scanned credit memo).

In contrast, Fast.io 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.

## Steps to Query SharePoint Documents with LangChain and Remote MCP

Integrating a LangChain agent with a synchronized Fast.io workspace eliminates the need to manage Entra ID app registrations, client secrets, or Graph API rate limits in application code. Follow this implementation guide to configure workspace synchronization and connect a LangChain tool-calling agent.

### 1. Define Target Document Scope in SharePoint

Identify the specific document libraries or project subfolders required for your agent's domain. Rather than syncing entire SharePoint tenants, isolate relevant repositories such as engineering specifications, vendor contracts, or corporate policies. Narrowing folder scope accelerates initial indexing and maintains clear security boundaries.

### 2. Connect Storage Synchronization in Fast.io

In the Fast.io web management console, establish the external storage link:

1. Open your designated workspace and navigate to Cloud Sync settings.
2. Select OneDrive, then pick the SharePoint document library.
3. Authorize access using standard Microsoft 365 OAuth credentials.
4. Select the specific folder path within the document library.
5. Choose your synchronization mode: one-way sync for read-only retrieval or two-way sync if your LangChain agents will generate files, meeting summaries, or reports to be mirrored back to SharePoint.
6. Define your sync schedule, such as an hourly recurring sync or on-demand manual trigger.

### 3. Verify Automatic Ingestion and Intelligence Mode

Upon initiating synchronization, Fast.io ingests documents in the background. Intelligence Mode automatically parses all file formats, computes semantic vector embeddings, and builds full-text search indexes. Scanned PDFs and image assets are parsed automatically, ensuring zero unreadable documents.

### 4. Create Scoped Fast.io API Credentials

Provision agent access tokens within the Fast.io dashboard:

1. Open your Organization Settings and select Developer Settings.
2. Generate a new API key scoped to the target workspace.
3. Store this credential in your deployment environment as `FASTIO_API_KEY`.

### 5. Construct the LangChain Tool-Calling Agent

LangChain agents interact with Fast.io's remote MCP endpoint using standard HTTP tool definitions. Fast.io serves its remote Streamable HTTP endpoint at `https://mcp.fast.io/mcp/key`, accepting standard Bearer token authorization headers.

Here is a production-ready Python script setting up a LangChain agent with Fast.io search tooling:

```python
import os
import httpx
from dotenv import load_dotenv
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

load_dotenv()

fastio_api_key = os.getenv("FASTIO_API_KEY")
workspace_id = os.getenv("FASTIO_WORKSPACE_ID")
fastio_mcp_url = "https://mcp.fast.io/mcp/key"

@tool
def query_sharepoint_workspace(search_query: str) -> str:
    """Searches the pre-indexed enterprise SharePoint workspace for relevant documents, passages, and citations using the Fastio storage search tool (see mcp.fast.io/skill.md)."""
    headers = {
        "Authorization": f"Bearer {fastio_api_key}",
        "Content-Type": "application/json"
    }
    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "storage",
            "arguments": {
                "action": "search",
                "profile_type": "workspace",
                "query": search_query
            }
        }
    }
    with httpx.Client(timeout=30.0) as client:
        resp = client.post(fastio_mcp_url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if "error" in data:
            return f"Fast.io MCP Error: {data['error'].get('message', 'Unknown failure')}"
        result = data.get("result", {})
        return str(result.get("content", "No matching passages located in the workspace."))

tools = [query_sharepoint_workspace]
model = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an enterprise research assistant. Use the query_sharepoint_workspace tool to inspect organizational documents before answering questions. Always cite the document source."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(model, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

response = executor.invoke({
    "input": "Summarize the key payment milestones and SLA penalties from the 2026 vendor agreements."
})
print(response["output"])
```

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 Comparison: Native Loader vs. Synchronized Workspace

Comparing native Graph ingestion with synchronized workspace retrieval highlights fundamental differences in operational complexity:

| Feature Dimension | Native LangChain SharePointLoader | Fast.io Synchronized Workspace |
|---|---|---|
| Integration Overhead | High (Entra ID app, secret rotation, Graph admin consent) | Low (uses the signed-in user's OAuth; some tenants require an administrator to approve third-party apps) |
| Graph Throttling Exposure | High (Direct Graph API calls subject to rate limits) | None during queries (Queries hit pre-indexed workspace) |
| Query Latency | High (Downloads full raw byte streams during execution) | Low (Background sync with instant pre-computed search) |
| Handling Scanned Records | Fails on image-only PDFs without external OCR | Universal parsing with automated OCR (zero unreadable files) |
| Structured Data Schema | None (Requires custom extraction chains) | Metadata Views with typed schema extraction |
| Multi-Cloud Support | SharePoint and OneDrive only | Unified search across OneDrive, Box, and Dropbox (SharePoint via OneDrive) |
| Concurrent Agents | Multiplies Graph API calls per agent | Shared remote MCP endpoint with no provider throttling |

### Governance, Lineage, and Plan Structure

Enterprise deployment requires clear oversight of data lineage and agent actions. Fast.io maintains an append-only, immutable audit log that records every file modification, access event, sync trigger, and AI query across the system. Access controls can be enforced granularly at the organization, workspace, folder, or file tier.

Every document in Fast.io tracks 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 [Fast.io 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 does LangChain connect to SharePoint document libraries?

LangChain connects directly to SharePoint libraries using the SharePointLoader component in langchain-community, which authenticates to Microsoft Graph via an Entra ID application registration. Alternatively, developers can sync SharePoint folders into an intelligent Fast.io workspace and query indexed files using LangChain tool calling against Fast.io's remote Model Context Protocol (MCP) server.

### How do I authenticate LangChain with Microsoft SharePoint?

Authentication requires creating an App Registration in the Microsoft Entra admin center with a Client ID, Tenant ID, and Client Secret. The application requires Microsoft Graph application permissions such as Files.Read.All and Sites.Read.All, which must receive directory-wide administrator consent. These credentials are then supplied to LangChain's SharePointLoader.

### How do I index SharePoint files for LangChain RAG without hitting Graph API throttling?

To prevent Microsoft Graph HTTP 429 rate limit errors when loading deep SharePoint repositories, synchronize target folders into a Fast.io workspace. Fast.io indexes document text, metadata, and scanned files in the background, allowing LangChain agents to retrieve targeted passages via remote MCP instead of traversing recursive folder trees over Microsoft Graph.

### What Microsoft Graph permissions does LangChain SharePointLoader require?

LangChain SharePointLoader requires Files.Read.All and Sites.Read.All application permissions under Microsoft Graph, or the scoped Sites.Selected permission for granular site access. An Azure tenant administrator must explicitly grant admin consent before background LangChain jobs can read document streams.

### Can a LangChain agent write updated documents back to SharePoint?

The native SharePointLoader in langchain-community is strictly read-only and cannot upload or update SharePoint files. In contrast, using Fast.io with two-way cloud synchronization enabled allows LangChain agents connecting over MCP to write new files, update existing documents, or collaborate via Notes, with updates syncing back to SharePoint on schedule.

### Why do scanned PDF documents fail to index in native LangChain loaders?

Standard LangChain loaders rely on basic PDF parsing libraries like pypdf that only extract digital text streams. Scanned contracts and image-based PDFs lack embedded font glyphs, causing the loader to produce empty Document objects. Fast.io overcomes this limitation by automatically applying OCR through Intelligence Mode, ensuring zero unreadable documents in the retrieval index.

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