# How to Build a Semantic Kernel Dropbox Connector for AI Agents

A Semantic Kernel Dropbox connector is a plugin or native memory store that connects Semantic Kernel AI agents to Dropbox file structures for prompt grounding and retrieval. Querying raw Dropbox folders directly introduces token bloat, rate limits, and fragile token refreshes. Syncing files into an intelligent Fastio workspace gives agents hybrid semantic search and precise excerpt retrieval over remote MCP.

Source: https://fast.io/resources/semantic-kernel-dropbox-connector/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-19

## How to Architect a Semantic Kernel Dropbox Integration

Connecting a Semantic Kernel AI agent directly to Dropbox storage via the Dropbox HTTP API immediately creates three operational bottlenecks: recursive folder traversal that exhausts API rate limits, brittle OAuth token refresh lifecycles in headless agent runtimes, and severe context window bloat caused by dumping raw binary document contents into prompt memory. The obstacle that stalls enterprise agent initiatives is rarely the reasoning ability of the underlying model, but rather the data transfer and retrieval architecture connecting the agent to existing cloud storage repositories.

In modern engineering and business teams, organizational knowledge, contracts, product specifications, and operational manuals reside across cloud storage services, particularly Dropbox folders. At the same time, development teams rely on Semantic Kernel, Microsoft's enterprise AI orchestration SDK for C# and Python developers building agentic workflows, to automate internal research, customer support, and operational analysis.

A Semantic Kernel Dropbox connector is a plugin or native memory store that connects Semantic Kernel AI agents to Dropbox file structures for prompt grounding and retrieval. Semantic Kernel operates by exposing native code and external APIs to language models as structured plugins. When an agent processes a user prompt, the model reviews available function descriptions, determines whether Dropbox access is necessary, and formats the function call arguments. Semantic Kernel coordinates the invocation, issues the underlying storage calls, and returns the response payload to the agent reasoning loop.

### Direct Dropbox API Plugins Versus Workspace Coordination

Developers connecting Semantic Kernel to Dropbox typically evaluate two architectural patterns:

1. Native Dropbox API Plugin Pattern: The engineering team creates a custom C# or Python plugin that issues calls directly to Dropbox API v2 endpoints, such as `/2/files/search_v2` and `/2/files/download`. The host application manages OAuth 2.0 refresh tokens, parses nested folders, handles pagination cursors, and downloads document byte streams into memory.

2. Workspace Synchronization and Remote MCP Pattern: The organization maintains its existing Dropbox folders as the primary interface for human teams, while synchronizing target folders into an intelligent Fastio workspace using Cloud Sync. Semantic Kernel agents then connect to the workspace through a remote Model Context Protocol (MCP) server over Streamable HTTP, executing targeted hybrid semantic searches without transferring raw file contents into prompt context.

### Architectural Comparison of Integration Paths

To understand how these two integration paths operate under production workloads, compare their core architectural dimensions:

| Architecture Dimension | Native Dropbox API Plugin | Workspace Cloud Sync via Remote MCP |
| :--- | :--- | :--- |
| Primary Endpoint | Dropbox API v2 (`api.dropboxapi.com/2/`) | Remote Fastio MCP Server (`https://mcp.fast.io/mcp/tools`) |
| Transport Protocol | Direct HTTPS REST requests | Remote Streamable HTTP MCP |
| Query Mechanism | Lexical keyword search and recursive directory walks | Pre-indexed hybrid search (full-text, vector, metadata) |
| Retrieval Unit | Entire binary files (PDF, DOCX, XLSX) | Targeted paragraph excerpts with citations |
| API Throttling Risk | High risk of HTTP 429 throttling during folder crawls | Zero live Dropbox API calls during agent execution |
| Context Token Cost | High token consumption from raw file payloads | Minimal token consumption per query turn |
| Authentication Scope | Dropbox OAuth 2.0 app credentials with refresh tokens | Scoped workspace API key (Bearer token) |

### Three-Phase Workflow for Dropbox Agent Retrieval

An effective architecture for connecting Semantic Kernel to Dropbox requires three discrete phases:

1. Authentication and permissions scoping: Configure Dropbox application registrations or workspace keys with scoped permissions, restricting the connector to designated folders rather than granting broad account-wide authority.
2. Workspace indexing via Cloud Sync: Synchronize target Dropbox folders into an intelligent workspace on a schedule or on demand, where files are automatically parsed and indexed for hybrid search.
3. Invoking search tools from Semantic Kernel plugins: Register the remote MCP toolset within the Semantic Kernel kernel builder, allowing the agent to retrieve precise, cited excerpts on demand instead of ingesting entire binary files.

Semantic Kernel's function calling depends on clear tool descriptions to prevent hallucinated file path lookups. When an agent lacks clear tool boundaries, it attempts to guess file system paths or traverses folders recursively. Fastio's search tool takes a query and returns matching passages directly, so the agent does not need to walk folders to find them.

## How to Build Native Dropbox Plugins for Semantic Kernel

The direct method for connecting Semantic Kernel to Dropbox involves building a native C# or Python plugin that interacts with the Dropbox API v2. Semantic Kernel plugins encapsulate APIs and native functions into collections that AI models can invoke through function calling.

In this approach, developers expose specific methods, such as searching folders, reading file metadata, and downloading document content streams, to the kernel using function annotations.

### Implementing a Native Dropbox Plugin in C#

In C#, a native plugin exposes methods decorated with the `KernelFunction` and `Description` attributes. The language model relies on these descriptions during planning to select the appropriate tool and generate valid arguments:

```csharp
using System;
using System.ComponentModel;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.SemanticKernel;

public class DropboxPlugin
{
    private readonly HttpClient _httpClient;
    private const string SearchEndpoint = "https://api.dropboxapi.com/2/files/search_v2";
    private const string DownloadEndpoint = "https://content.dropboxapi.com/2/files/download";
//
    public DropboxPlugin(string dropboxAccessToken)
    {
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", dropboxAccessToken);
    }
//
    [KernelFunction("SearchFiles")]
    public async Task<string> SearchFilesAsync(
        [Description("Keyword search query to find documents in Dropbox")] string query,
        [Description("Path prefix to limit search scope, such as /Contracts")] string folderPath = "",
        CancellationToken cancellationToken = default)
    {
        var requestBody = new
        {
            query = query,
            options = new
            {
                path = string.IsNullOrEmpty(folderPath) ? null : folderPath,
                max_results = 10,
                file_status = "active"
            }
        };
//
        var content = new StringContent(
            JsonSerializer.Serialize(requestBody),
            Encoding.UTF8,
            "application/json");
//
        var response = await _httpClient.PostAsync(SearchEndpoint, content, cancellationToken);
        response.EnsureSuccessStatusCode();
//
        var responseJson = await response.Content.ReadAsStringAsync(cancellationToken);
        return responseJson;
    }
//
    [KernelFunction("DownloadTextDocument")]
    public async Task<string> DownloadTextDocumentAsync(
        [Description("The lowercased path or unique ID of the file, such as /finance/q3.txt")] string filePath,
        CancellationToken cancellationToken = default)
    {
        var request = new HttpRequestMessage(HttpMethod.Post, DownloadEndpoint);
        request.Headers.Add("Dropbox-API-Arg", JsonSerializer.Serialize(new { path = filePath }));
//
        var response = await _httpClient.SendAsync(request, cancellationToken);
        response.EnsureSuccessStatusCode();
//
        using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
        using var reader = new StreamReader(stream);
        var text = await reader.ReadToEndAsync(cancellationToken);
//
        // Truncate to mitigate immediate context window flooding
        return text.Length > 8000 ? text.Substring(0, 8000) + "... (truncated)" : text;
    }
}
```

### Registering the Plugin with Semantic Kernel

To enable an agent to call the Dropbox plugin during reasoning, register the plugin with the kernel builder and configure automatic function invocation:

```csharp
using System;
using System.Threading.Tasks;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;

public class Program
{
    public static async Task Main(string[] args)
    {
        var builder = Kernel.CreateBuilder();
        builder.AddOpenAIChatCompletion("gpt-4o", Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);
//
        // Register the native Dropbox plugin
        var dropboxToken = Environment.GetEnvironmentVariable("DROPBOX_ACCESS_TOKEN")!;
        builder.Plugins.AddFromObject(new DropboxPlugin(dropboxToken), "DropboxPlugin");
//
        var kernel = builder.Build();
//
        // Enable automatic tool selection and invocation
        var executionSettings = new PromptExecutionSettings
        {
            FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
        };
//
        var chatService = kernel.GetRequiredService<IChatCompletionService>();
        var history = new ChatHistory();
        history.AddUserMessage("Find our standard vendor agreement in the /Contracts folder and summarize the payment terms.");
//
        var response = await chatService.GetChatMessageContentAsync(
            history,
            executionSettings: executionSettings,
            kernel: kernel);
//
        Console.WriteLine(response.Content);
    }
}
```

### Dropbox OAuth 2.0 and Token Lifecycle Management

Dropbox uses short-lived access tokens that expire after 4 hours. For interactive user applications, refreshing tokens through a standard web redirect flow works smoothly. However, autonomous background agents and unattended worker services require offline token refresh:

1. Offline Access Type: When initiating OAuth authorization, applications must specify `token_access_type=offline` to receive a long-lived refresh token alongside the short-lived access token.
2. Token Storage and Refresh Logic: Native plugins must store the refresh token securely, check token expiration timestamps before each API call, and exchange the refresh token for a fresh access token via `POST https://api.dropboxapi.com/oauth2/token` when expired.
3. Permission Scopes: The Dropbox App Console requires selecting specific scopes. For reading document repositories, the app requires `files.metadata.read` to query file properties and `files.content.read` to download file streams.

### Three Operational Failure Modes in Direct Integrations

Building and maintaining custom Dropbox API plugins introduces ongoing operational friction:

1. Dropbox API Rate Limits and HTTP 429 Throttling: Dropbox applies rate limits per authorization: per linked user for user-linked apps, and per team when team-linked apps call Business Endpoints. When an agent recursively traverses deep directory trees or issues rapid concurrent requests across large document sets, Dropbox returns HTTP 429 Too Many Requests responses. Custom plugins must parse the `Retry-After` header and execute exponential backoff retries.
2. Empty Folder Traversal Loops: When an agent attempts to locate documents without exact paths, it frequently calls listing endpoints across empty subfolders. Because a model working through tool calls evaluates directories step by step, traversing empty directories consumes valuable model inference cycles and quickly burns API quotas.
3. Binary Document Parsing Overhead: Dropbox returns raw byte streams for files. Document collections frequently contain PDF, Word (`.docx`), PowerPoint (`.pptx`), and Excel (`.xlsx`) files. Native plugins must bundle third-party parsing libraries to extract plain text before passing data to the model.

## Why Direct Document Ingestion Strains Agent Context Windows

Finding a document in Dropbox is only the first step in an agent workflow. The primary reason developers connect Semantic Kernel to Dropbox is to allow the agent to extract information, answer factual questions, and synthesize business data. This is where direct Dropbox API integrations encounter fundamental limits.

Connecting via remote MCP allows Semantic Kernel agents to perform targeted semantic searches without downloading multi-gigabyte document libraries. When agents interact directly with raw storage APIs, they face significant context window bloat and reasoning degradation.

### The Document Payload Problem

When a native plugin retrieves a file from Dropbox, it downloads the entire file payload over HTTP into application memory. A corporate contract, technical specification, or compliance report often spans dozens of dense pages.

Converting a long document into text yields massive token payloads. Injecting this raw text payload directly into the language model prompt context causes several immediate problems:

1. Context Window Exhaustion: While modern frontier models feature large context windows, filling working memory with entire documents leaves little room for conversation history, intermediate tool schemas, and multi-step reasoning traces.
2. Attention Degradation: Language models experience reduced recall accuracy when searching for specific facts in bloated prompts. When relevant details are surrounded by pages of boilerplate text, the model can overlook important clauses or produce incomplete summaries.
3. Compounding Token Costs: In multi-turn agent loops, prompt tokens accumulate on every consecutive turn. An agent that reads an entire document during an initial step must process that full payload again during subsequent reasoning turns, increasing inference latency and operational API costs.

### The Limits of Keyword Matching in Dropbox Search

The Dropbox `/2/files/search_v2` endpoint is a keyword search over files and folders. It does not perform semantic, meaning-based retrieval.

Consider a user asking a Semantic Kernel agent: "What are our regulatory compliance obligations under the vendor security policy?"

If the Dropbox document phrases these controls as "mandatory audit standards" or "third-party risk management protocols", a keyword search can return zero results because the exact keywords "compliance obligations" do not appear in the text. The agent concludes that the policy does not exist, leading to hallucinations or aborted workflows.

### The Maintenance Burden of Self-Hosted Vector Stores

To solve context bloat and substring search limitations, engineering teams frequently attempt to build a custom Retrieval-Augmented Generation (RAG) system beside Semantic Kernel.

In Semantic Kernel, vector search relies on vector store abstractions (`Microsoft.Extensions.VectorData.Abstractions`, `VectorStore`, `IVectorSearchable<TRecord>`). The vector store abstraction is a low level API for adding and retrieving data from vector stores.

Implementing this architecture directly requires deploying and maintaining an extensive secondary data pipeline:

* Provisioning and maintaining a dedicated vector database, such as Azure AI Search, Pinecone, or Qdrant.
* Developing document chunking microservices that extract text, split paragraphs, and generate dense vector embeddings.
* Implementing change-tracking workers using Dropbox list folder continue cursors (`/2/files/list_folder/continue`) to detect file updates and re-index modified documents.
* Reconciling deleted files and tombstone records across the vector store.
* Managing database migrations, index schema updates, and embedding model version upgrades.

For most engineering teams, maintaining a dedicated vector database and synchronization infrastructure just to make Dropbox files searchable by agents introduces unnecessary complexity and recurring cloud hosting expenses.

## How to Connect Semantic Kernel to Dropbox Through Fastio Remote MCP

A more dependable architectural pattern decouples the cloud storage repository from the agent retrieval engine. Instead of forcing Semantic Kernel to act as a custom Dropbox document parser and sync client, organizations maintain Dropbox as their existing human document interface while synchronizing relevant folders into an intelligent Fastio workspace.

### Scheduled Cloud Sync for Dropbox Folders

Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand, never real-time. Files sync directly between cloud backends without consuming local developer bandwidth or requiring persistent background daemons on developer machines.

Because synchronization occurs in the background, agents avoid executing live, slow Dropbox API calls during user interactions. Files remain versioned and auditable within the workspace.

### Built-In Intelligence and Hybrid Search

When documents arrive in the workspace, Fastio Intelligence Mode automatically indexes files for hybrid search. This integrates full-text keyword indexing, semantic vector search, and search-by-metadata-value without requiring external vector databases or embedding pipelines.

When an agent needs information from a document, it queries the workspace search tool. Intelligence Mode returns the precise paragraphs and text excerpts relevant to the query, complete with document citations. The agent receives only the context necessary to formulate an accurate answer, keeping prompt tokens small and response latency low.

### Structured Document Extraction with Metadata Views

For workflows requiring structured data extraction from Dropbox assets, Fastio provides [Metadata Views](/product/document-data-extraction/). Metadata Views turn unstructured documents into live, queryable tables. Users or agents describe the fields they want extracted in natural language, and the system designs a typed schema (Text, Integer, Decimal, Boolean, URL, JSON, Date & Time), matches workspace files, and extracts structured data from PDFs, scanned pages, spreadsheets, and presentations.

Agents can query these structured views directly via MCP to retrieve precise data fields, such as invoice totals, contract expiration dates, or policy numbers, without loading full documents into prompt context.

### Connecting Semantic Kernel via Streamable HTTP Remote MCP

Semantic Kernel agents connect to Fastio through the Model Context Protocol (MCP) using Streamable HTTP. Fastio hosts a remote MCP server, eliminating the need to install local daemon processes, manage Docker containers, or configure complex bridge packages.

For general agent clients and application backends calling named tools, the connection endpoint is `https://mcp.fast.io/mcp/tools`. Coding agents connect through `https://mcp.fast.io/mcp/code`. Agents authenticate by providing a scoped workspace API key as a Bearer token in the connection header: `Authorization: Bearer <FASTIO_API_KEY>`. For detailed client configuration steps, consult the [Fastio MCP documentation](https://mcp.fast.io/docs) or the [storage for agents guide](/storage-for-agents/).

The following C# example follows the pattern in Semantic Kernel's own MCP sample: it connects with the official ModelContextProtocol C# SDK (NuGet package `ModelContextProtocol`) over Streamable HTTP and loads the Fastio tools as kernel functions:

```csharp
#pragma warning disable SKEXP0001 // AsKernelFunction is marked experimental
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.SemanticKernel;
using ModelContextProtocol.Client;
// Connect to the Fastio MCP server over Streamable HTTP with a scoped API key
var transport = new HttpClientTransport(new HttpClientTransportOptions
{
    Endpoint = new Uri("https://mcp.fast.io/mcp/tools"),
    TransportMode = HttpTransportMode.StreamableHttp,
    AdditionalHeaders = new Dictionary<string, string>
    {
        ["Authorization"] = $"Bearer {Environment.GetEnvironmentVariable("FASTIO_API_KEY")}"
    }
});
await using var mcpClient = await McpClient.CreateAsync(transport);
// Load the Fastio tools (storage, storage_manage, workspace and the rest) as kernel functions
var tools = await mcpClient.ListToolsAsync();
var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion("gpt-4o", Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);
var kernel = builder.Build();
kernel.Plugins.AddFromFunctions("Fastio", tools.Select(tool => tool.AsKernelFunction()));
// Let the model call the storage tool's search action instead of walking folders
var settings = new PromptExecutionSettings
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};
var result = await kernel.InvokePromptAsync(
    "Search the Contracts workspace for our standard vendor agreement and summarize its payment terms.",
    new KernelArguments(settings));
Console.WriteLine(result);
```

The model then calls the `storage` tool with `action: "search"` and a `query`, and the remote MCP server searches the pre-indexed corpus directly instead of walking folders. Any writes go through `storage_manage`.

### Measured Connector Performance

In the [connector benchmarks Fastio publishes](https://fast.io/benchmarks/), Fastio was measured the fastest and the lowest cost of the providers tested. The other providers (Box, Dropbox, Google Drive, and OneDrive) were each tested through their own native connector in Claude Cowork.

### Workspace Capacity and Plans

Fastio provides predictable capacity for team and agent workflows. Storage and member seats are bundled into monthly plans:

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

Monthly plans start with a 14-day free trial, which requires a credit card. Credits meter AI search and document extraction, while storage and seats come included with each subscription.

## What Production Agent Deployments Require: Scoping, Concurrency, and Audit Logs

Deploying a Semantic Kernel storage connector in enterprise production requires strict controls around access scoping, multi-agent concurrency, and compliance visibility.

### Enforcing Scoped Workspace Boundaries

A primary vulnerability in custom Dropbox agent connectors is assigning the agent a broad application credential with account-wide read access. If the agent encounters prompt injection or misinterprets user intent, it can access and expose confidential files across unrelated business departments.

Fastio permissions are set per organization, workspace, and share through member roles. There are no folder-level or file-level permissions; every workspace member reaches the whole workspace according to their role. To isolate an agent, create a dedicated workspace containing only the specific project assets the agent requires, and sync only relevant Dropbox folders into that workspace. This sandboxes the agent, ensuring it cannot access or exfiltrate unrelated organizational data.

### Concurrency and Per-File Version History

When multiple Semantic Kernel agents or human team members collaborate on the same file repository, race conditions occur. Two agents attempting to update a shared project log or analysis document simultaneously can cause silent overwrites.

Fastio protects concurrent workflows through per-file version history and advisory file locks. Agents acquire, heartbeat, and release advisory file leases through MCP actions (`lock-acquire` and `lock-release` on the `storage_manage` tool, and `lock-status` on the `storage` tool). Other members can see who holds the lock. Locks never grant exclusive write rights; concurrent writes both land, and version history preserves every version, allowing teams to review changes or restore prior copies without data loss.

### Detailed Activity Log and Audit Tracking

Enterprise security teams require visibility into agent modifications. Fastio maintains a detailed activity log of changes across the organization, recording file uploads, edits, moves, deletions, membership adjustments, and share creation by humans and agents alike. The activity log records modifications rather than read-only file views or downloads, providing a clean audit trail of workspace state changes without noise.

Fastio also supports ownership transfer from agent to human. An agent can be programmed to initialize an organization, construct workspaces, sync Dropbox folders, and build Metadata Views, then transfer organization ownership to a human administrator while retaining administrative access for ongoing maintenance.

### Integrated Document Signing Workflows

When agent workflows produce or manage finalized legal contracts, vendor statements of work, or onboarding agreements originating from Dropbox, Fastio e-signature allows teams to send documents for signature directly from a workspace. The feature supports signers in sequence or parallel, optional one-time passcodes per signer, a tamper-evident audit certificate, and the executed copy filed back into the workspace. Detailed workflows are documented at [/product/e-signature/](/product/e-signature/).

### Choosing the Right Integration Architecture

Use a direct native Dropbox API plugin when building simple internal tools that only need to list a handful of files by name or inspect basic metadata properties in a single, well-known Dropbox folder.

When building production agents that must search large document collections, answer complex questions using semantic retrieval, extract structured records, or collaborate safely across multi-agent environments, synchronizing Dropbox folders into Fastio workspaces and connecting Semantic Kernel via remote MCP provides a more secure, scalable, and cost-effective foundation.

## Frequently asked questions

### How do I create a Semantic Kernel plugin for Dropbox?

You create a Semantic Kernel plugin for Dropbox by defining a C# or Python class that wraps Dropbox API v2 endpoints, decorating methods with the KernelFunction and Description attributes. The plugin issues HTTP requests to endpoints like /2/files/search_v2 and /2/files/download using OAuth 2.0 credentials, allowing the language model planner to invoke Dropbox operations during reasoning.

### Can Semantic Kernel search Dropbox document contents?

Semantic Kernel can search Dropbox files using the /2/files/search_v2 endpoint for basic keyword matching. For conceptual queries, syncing Dropbox folders to a Fastio workspace provides automatic hybrid semantic search, full-text indexing, and metadata filtering without needing a separate vector database.

### How does Semantic Kernel handle file permissions in Dropbox?

In direct Dropbox API integrations, the agent inherits all permissions granted to its OAuth 2.0 access token, which often grants broad account-wide access. When connecting through Fastio, organizations sandbox the agent by placing target files into an isolated workspace with role-based member permissions set per organization, workspace, and share.

### What causes Dropbox API searches to return HTTP 429 errors?

Dropbox applies rate limits per authorization, per linked user or per team for team-linked apps. When an agent recursively traverses deep directory trees, lists thousands of folder items, or issues rapid concurrent queries, Dropbox returns HTTP 429 Too Many Requests responses. Connectors must parse the Retry-After header and apply exponential backoff.

### How does Fastio Cloud Sync connect to Dropbox folders?

Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Synchronization operates in the background and is never real-time, transferring files into an isolated workspace where documents are pre-indexed for agent retrieval.

### Does Fastio provide semantic search without a separate vector database?

Yes. Fastio Intelligence Mode automatically indexes uploaded and synchronized documents for hybrid search, combining full-text keyword indexing, semantic vector search, and search-by-metadata-value without requiring external vector databases, embedding models, or custom chunking scripts.

### What is the difference between direct Dropbox API search and workspace hybrid search?

Direct Dropbox API search relies on exact keyword matching and file downloads, forcing the agent host to parse binary files and chunk text. Workspace hybrid search indexes documents off-host and combines exact keyword matching with dense vector retrieval, returning only concise, citation-backed excerpts to the agent.

### Does Fastio sync with Google Drive?

Yes. Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand, allowing teams to preserve existing storage while giving AI agents unified MCP access.

## Sources

- [Microsoft Learn: Plugins in Semantic Kernel](https://learn.microsoft.com/en-us/semantic-kernel/concepts/plugins/): Semantic Kernel plugins encapsulate APIs and native functions into collections that AI models can invoke through function calling.
- [Microsoft Learn: What are Semantic Kernel Vector Stores?](https://learn.microsoft.com/en-us/semantic-kernel/concepts/vector-store-connectors/): The vector store abstraction is a low level API for adding and retrieving data from vector stores in Semantic Kernel.

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