How to Query Fastio Metadata Views in Cline via MCP

Two coding agents pointed at the same repository will happily overwrite each other's work, and neither will notice. Similarly, when a coding assistant like Cline needs to extract fields from hundreds of unstructured documents, querying them one by one via RAG is slow, inaccurate, and consumes millions of context tokens. The fix is a persistent workspace that automatically turns document folders into structured, queryable data grids. Querying metadata views via MCP enables coding agents to treat folders of unstructured documents (such as PDFs, invoices, and specs) as a live, typed relational database.

Developers evaluating document extraction patterns typically start with traditional approaches. One common option is writing custom Python parsing scripts that run local PDF extractors or optical character recognition engines. Another is uploading files to cloud storage buckets or folders in legacy file-sync tools and using their APIs to retrieve text blobs. However, these methods require writing custom parsing logic for each document layout or building complex ingestion pipelines that glue databases, search indexes, and vector stores together. Standalone vector databases can find semantic matches but fail when you need precise database-like operations. They cannot tell you which documents are expiring within a certain range or which invoice totals exceed a budget limit.

This guide explains how to use Fastio Metadata Views to solve this structured query problem. Rather than treating documents as plain text files, Metadata Views extract specific, typed fields using artificial intelligence. The resulting data is stored in a structured grid that is accessible programmatically. By connecting Cline to the Fastio MCP server, developers give their coding agents the ability to read, sort, and query these fields. This reduces the number of tokens the agent must consume and helps teams build faster, more reliable document automation pipelines.

Before a coding agent can query document data, developers must define the fields they want to extract. In legacy systems, this process requires building templates or defining regular expression coordinates for each document type. If a vendor changes their invoice layout by a few pixels, the template breaks. Fastio Metadata Views replace these rigid rules with natural language schemas.

Setting up a Metadata View is straightforward. Developers describe the columns they need in plain English. For example, a finance team processing invoices might ask for the invoice number, vendor name, issue date, total amount, and line items. Fastio's AI analysis engine scans the target folder, designs the typed schema, and maps the layout. The platform supports seven distinct data types:

• Text: Used for names, counterparties, IDs, and alphanumeric strings.
• Integer: Used for counts, page numbers, and discrete quantities.
• Decimal: Used for currency values, totals, tax amounts, and rates.
• Boolean: Used for binary flags, such as approval status or signature completion.
• URL: Used for external links, source URLs, or references.
• JSON: Used for structured arrays, nested lists of line items, or metadata maps.
• Date & Time: Used for effective dates, expiration dates, and timestamps.

Once the columns are configured, the system matches incoming files in the workspace and populates the spreadsheet grid. When new files are imported from cloud storage providers (such as Google Drive, Dropbox, Box, or OneDrive via OAuth, or URL import, which you can read about on the cloud import page), the platform automatically runs extraction. Developers can add new columns to the schema at any point. The platform extracts the new fields incrementally, meaning you do not have to reprocess the entire workspace to add a column. This structured extraction layer remains separate from Intelligence Mode, which handles semantic document search and file-level QA. While Intelligence Mode indexes files for conversational retrieval, Metadata Views build the relational database layer that coding agents need for structured operations.

Connecting Cline to the workspace requires configuring connection settings. The Fastio MCP server is a remote hosted service, not a local npm package or executable script. Cline does not launch it via local CLI commands or arguments. Instead, the assistant establishes a connection to the remote endpoint over the Streamable HTTP transport, which provides a persistent, low-latency communication channel.

To connect Cline to the endpoint, developers add the server definition to their settings file. The path is typically within the VS Code application storage directory. The developer resources are documented on the developer storage page. Below is the configuration block for the setting file:

{
  "mcpServers": {
    "fastio": {
      "type": "streamableHttp",
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_TOKEN"
      }
    }
  }
}

Authentication uses a long-lived API token, which can be acquired from the Fastio developer console. This token is passed in the Authorization header with each JSON-RPC request. By using the remote transport, the connection avoids the timeouts and connection drops that commonly impact legacy Server-Sent Events (SSE) connections when they pass through corporate load balancers or proxy servers. Once Cline registers this configuration, it gains access to the workspaces, files, and Metadata Views matching the token's permission scopes. The agent can then browse workspaces, read file contents, and query structured extractions without requiring local document parsers.

Query structured document data directly from Cline

Create typed schemas, extract file fields using AI, and query your workspace metadata views programmatically. Starts with a 14-day free trial.

Start 14-Day Trial

Once Cline is connected, it can query Metadata Views programmatically. The Fastio MCP server exposes tools that allow the agent to fetch structured tables instead of reading entire raw text files. The primary tool for this action is query_metadata_view.

To run a query, Cline passes the target workspace identifier, the view identifier, and optional filter arguments. For example, if a coding agent is tasked with finding all unpaid invoices that exceed a specific amount, it can invoke query_metadata_view with a filter schema. The parameters match standard JSON structures:

{
  "workspace_id": "ws_9876543210",
  "view_id": "view_invoice_records",
  "filters": [
    {
      "column": "total_amount",
      "operator": "greater_than",
      "value": 1000.00
    },
    {
      "column": "approved",
      "operator": "equals",
      "value": false
    }
  ],
  "limit": 50
}

The MCP server executes the query over the extracted database grid and returns a clean JSON array containing the matching rows. Each row includes the extracted field values along with the file path and download URL.

This structured query pattern has a major impact on agent efficiency. If the agent had to read the text of fifty invoice documents to extract totals and check approval status, it would consume hundreds of thousands of context tokens. In contrast, querying the pre-extracted Metadata View takes a single tool call and returns only the relevant records. The agent can immediately process the filtered results, identify high-value unpaid files, and write renewal summaries or alerts directly to the workspace.

Using Cline to build and query workspaces provides a scalable way to organize team resources. A developer can write a script or prompt Cline to create a workspace, import folder structures, configure the Metadata Views, and run initial extractions. Once the workspace is set up and the documents are processed, the agent can hand the entire system over to a human owner.

Fastio supports this handoff with a built-in ownership transfer feature. The agent generates a transition link in the dashboard. The human client clicks the link, joins the organization, and takes ownership of the subscription. The agent can retain admin credentials to continue querying metadata, modifying schemas, and updating files, while the client takes responsibility for billing and user management.

This handoff fits with the platform's pricing. Creating a user account is free, but executing real tasks requires an organization on a paid subscription. Every organization starts with a 14-day free trial that requires a credit card. Subscriptions are divided into three plans, which you can compare on our pricing page:

• Starter: $29 per month (or $24 per month billed annually), providing 5 seats, 1 TB of storage, and 300,000 credits for AI tasks.
• Business: $99 per month (or $83 per month billed annually), supporting 20 seats, 10 TB of storage, and 1,200,000 credits.
• Growth: $299 per month (or $249 per month billed annually), supporting 50 seats, 50 TB of storage, and 4,500,000 credits.

By organizing documents into structured views and mounting them via MCP, teams can build AI-native directories that humans and agents can share. Every file edit, upload, and metadata query is recorded in the append-only audit log, ensuring a clear record of action. This persistent, versioned workspace serves as the foundation for multi-agent systems, helping coding tools and human teams collaborate on the same file substrate, which is detailed on the workspaces product page.