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

Connecting Devin AI to Fast.io workspaces via the Model Context Protocol provides autonomous agents with direct, programmatic access to Devin AI custom metadata views. Instead of writing custom parsing scripts, Devin AI uses Fast.io for devin metadata extraction, defining metadata columns in plain English. This allows the agent to automatically extract information and query metadata views in Devin.

Source: https://fast.io/resources/devin-ai-custom-metadata-views/
Author: [Tom Langridge](https://fast.io/authors/tom-langridge/)
Last reviewed: 2026-08-20

## Why Devin AI Needs Custom Metadata Views for Structured Extraction

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](/product/document-data-extraction/) 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 Configure the Fast.io MCP Connection in Devin AI

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](https://mcp.fast.io/docs) 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:

```bash
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:

```bash
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:

```json
{
  "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__`.

## Defining and Triggering Metadata Views Programmatically

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.

## How to Query Extracted Metadata Fields inside Devin AI

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.

## Handoff Patterns and Project Persistence

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](/storage-for-agents/) and our [pricing options](/pricing/).

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.

## Frequently asked questions

### How do I add an MCP server to Devin AI?

You can add an MCP server to Devin AI using the Devin CLI with the command `devin mcp add <name> --url <URL>`. For servers requiring authentication, pass the authorization token using the `-H` or `--header` option, which saves the configuration to the project-level `.devin/mcp_config.local.json` file.

### How can Devin AI access structured metadata?

Devin AI accesses structured metadata by connecting to the Fast.io MCP server. Through this connection, the agent queries Metadata Views, which are structured data tables extracted from unstructured files. The agent uses the metadata tool to retrieve schema structures and query values programmatically.

### What file formats are supported by Fast.io Metadata Views?

Fast.io Metadata Views support a wide variety of formats including PDFs, images, Word documents, spreadsheets, presentations, scanned pages, and handwritten notes. The underlying AI automatically extracts structured fields from these files without requiring templates or OCR rules.

### Can Devin AI define the metadata extraction columns dynamically?

Yes. Devin AI can define metadata extraction columns dynamically using natural language descriptions. The Fast.io MCP metadata tool takes these descriptions and uses Gemini Pro to suggest the schema, match the relevant files in the workspace, and run the extraction process.

## Sources

- [Model Context Protocol Documentation](https://modelcontextprotocol.io/introduction): The Model Context Protocol standardizes how AI applications connect to external data sources and tools.

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