How to Query Fast.io Custom Metadata Views in Devin AI via MCP

If an AI agent only interacts with files using raw reads and writes, it spends most of its context window parsing unstructured text and guessing schema structures. Connecting Devin AI to Fast.io's metadata layer through the Model Context Protocol solves this by exposing structured, pre-extracted document schemas directly to the agent's toolset. Custom metadata views in Fast.io allow AI agents to query structured schemas extracted from unstructured files using plain English descriptions. This capability changes how agents work with storage.

Coding agents like Devin AI frequently handle projects that involve processing incoming files, sorting records, or analyzing documents. In a typical setup, Devin AI must download each file, write custom parsing scripts, extract the relevant fields, and write them back to a database. This custom pipeline is fragile. It breaks when file formats change, and it consumes significant agent runtime and tokens.

Fast.io provides an alternative. By using Fast.io as a shared, intelligent workspace layer, Devin AI can interact with files that have already been indexed and structured. Differentiate this from standard search or summarization (which Fast.io handles via Intelligence Mode). Metadata Views act as the structured extraction layer. Instead of running a general search, Devin AI queries a defined data grid containing specific, typed fields.

These views turn unstructured files into a clean database. When Devin AI connects to a workspace, it can query metadata columns that represent extracted values. This approach works on diverse file types including PDFs, images, Word documents, spreadsheets, presentations, scanned pages, and handwritten notes. The agent does not need to build OCR rules or configure templates. Fast.io extracts the values automatically, presenting them as a sortable, filterable spreadsheet that both the agent and human developers can access.

• How to Query Fastio Metadata Views in Cline via MCPQuerying unstructured files via conversational search is slow and resource-heavy for coding agents. Fastio Metadata...
• Claude OneDrive MCP: Connect Claude to Microsoft OneDrive via Fast.ioClaude OneDrive MCP connects Anthropic Claude models to Microsoft OneDrive storage for reading, searching, and...
• Devin AI Dynamic Metadata Extraction: Tagging & Structuring Agent FilesDevin AI dynamic metadata extraction automatically analyzes document properties, tags, and structural data to enhance...
• How to Use MCP with Devin AIDevin AI supports three MCP surfaces, not one: the in-product marketplace, the free DeepWiki MCP server for public...
• Automating PDF Annotations and Reviews with Devin AI and Fast.ioEphemerality in AI coding sandboxes often leaves intermediate build logs and feedback comments stranded. Setting up a...
• Devin AI Automated Cloud Import: Ingesting Assets to Persistent StorageDevin AI operates in isolated micro-VM sandboxes where local files vanish when sessions terminate. Connecting external...

More on this subject: Devin (103 guides)

Devin AI manages its Model Context Protocol connections through configuration files. The Devin CLI handles both global and project-scoped MCP configurations. This scoping allows developers to define connections that apply to the entire system or only to a specific repository.

To connect Devin AI to Fast.io, you use the Devin CLI. The Fast.io MCP server is a remote service. It is not an npm package, and there is no local npm command to run it. Instead, the server runs over Streamable HTTP. The correct endpoint for the connection is the Fast.io remote endpoint. Refer to the Fast.io MCP documentation for setup details.

Because Fast.io requires authentication, you must pass your API key as a header. You can configure this using the Devin CLI. Run the following command:

devin mcp add fastio --url https://mcp.fast.io/mcp/code -H "Authorization: Bearer YOUR_FASTIO_API_KEY"

This command instructs the Devin CLI to register a new remote server named fastio. The CLI automatically infers that the transport type is HTTP. It saves this configuration to the local scope. By default, local configurations are stored in the project-level config file:

.devin/mcp_config.local.json

This file is gitignored. This ensures that your private API key is never committed to version control. If you prefer to configure the server globally for all projects, you can add the user scope flag:

devin mcp add fastio --url https://mcp.fast.io/mcp/code -s user -H "Authorization: Bearer YOUR_FASTIO_API_KEY"

This saves the connection to your user-level configuration path:

~/.config/devin/mcp_config.json

Once configured, the resulting local JSON configuration file contains the server endpoint and authorization headers:

{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp/code",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_KEY"
      }
    }
  }
}

Once the connection is established, Devin AI automatically registers the toolset. All subsequent file, workspace, and metadata operations are exposed to the agent as tools under the prefix mcp__fastio__.

Once connected, Devin AI can use the Fast.io MCP tools to create, configure, and manage structured data extraction views. The primary tool for these operations is mcp__fastio__metadata.

When files are uploaded to a workspace, Devin AI can trigger the creation of a Metadata View. In this step, the agent defines the columns it wants to extract by describing them in plain English. Devin AI does not need to define complex regular expressions or parser code. The underlying AI engine in Fast.io, powered by Gemini Pro, suggests and designs the typed schema. It maps the columns to the correct data types and extracts example values from real files.

The metadata tool exposes actions such as view-create (to define a new schema), view-list (to list existing views), and view-get (to inspect a view). Fast.io supports seven metadata field types:

• Text: For strings, names, and general labels
• Integer: For whole numbers like item counts or quantities
• Decimal: For precise numeric values such as pricing, weights, and ratings
• Boolean: For true or false flags like payment status or signature presence
• URL: For web links and document references
• JSON: For complex structured objects and arrays
• Date & Time: For timestamps, deadlines, and execution dates

As an example, if Devin AI is processing a batch of corporate invoices, it can describe the required schema using natural language. The agent calls the metadata tool with column descriptions like:

• Vendor name
• Invoice number
• Due date
• Total amount
• Line items

The Fast.io engine reads this request, designs the schema matching those fields, scans the workspace for incoming documents, and runs the extraction. This process works with many file types. The agent can ingest standard PDFs, image scans of receipts, spreadsheets, or even handwritten notes. Once the extraction is complete, Fast.io populates a structured data grid. Devin AI can add new columns at any time without forcing Fast.io to reprocess the existing documents.

With the data extracted, Devin AI can query the results programmatically. The agent does not need to fetch and read whole documents to find specific details. Instead, it queries the Metadata View database.

Devin AI can perform exact queries or use Fast.io's hybrid search. Hybrid search combines full-text index matching with semantic search and search-by-metadata-value. When workspace intelligence is enabled, Devin AI can search files based on the values in the extracted columns. The agent sends queries directly to the storage search endpoint. It can filter results by specific conditions, such as:

• Total amount greater than one thousand
• Due date before a specific date
• Verification status set to false

The search returns structured JSON data containing the matching file records, the exact metadata values, and the passages from the source documents. This allows Devin AI to quickly find relevant files and act on them. For example, if Devin AI is tasked with identifying unpaid invoices, it can query the view for records where the payment status is false. It can then extract the vendor's email address and draft a reminder.

This approach is more efficient than using standard cloud storage or running a separate vector database. When using traditional storage like Amazon S3 or Google Drive, an agent must download files, run local parser libraries, write database schemas, and manage search indexes. With Fast.io, the file storage, document rendering, AI extraction, and query API all live in a single unified workspace. Devin AI uses the same MCP server to upload files, trigger extraction, and query results. This reduces latency, token consumption, and code complexity.

Query document metadata directly in Devin AI

Deploy the Fast.io MCP server to connect Devin AI to your organization's workspaces. Define custom metadata schemas, automate document data extraction, and query structured views using natural language. Every organization starts with a 30-day trial, credit card required.

Start 30-Day Trial

A major advantage of using Fast.io is the ease of handoff between Devin AI and human team members. Because they share the same workspaces, humans and agents can collaborate on the same file sets.

During a project, Devin AI can set up the workspace, import files from cloud services like Google Drive, Dropbox, OneDrive, or Box using Cloud Import, and run the metadata extraction. All of this happens programmatically. While Devin AI works via the MCP API, human supervisors can view the progress in real time. They see the extracted metadata fields populate a spreadsheet-like data grid in the Fast.io web interface. Humans can sort, filter, and edit the columns inline, or click through to see the source documents.

If Devin AI is building a document processing system for a client, it can manage the entire setup. When the work is complete or the agent's credits run low, Devin AI can transfer ownership of the organization to a human user. This is done by generating a transfer token:

mcp__fastio__org action=transfer-token-create

The agent provides the human supervisor with the claim link. The human accepts the link, claims the organization, and configures billing. The agent retains administrative access to continue managing files and running queries. Developer workflows can learn more about storage for agents and our pricing options.

Every organization starts with a 30-day free trial, which requires a credit card. Doing real work requires an organization on a paid subscription. Plans are Starter, Business, and Enterprise. This structure ensures that developers can start testing Devin AI integrations during the trial, and transition to a production subscription once the agent's workspace configuration is ready.