# Sensible MCP for AI Agents AI Agent Connect

> Sensible MCP for AI Agents — Extract structured data from PDFs, images, and Word documents. This Connector turns unstructured files into clean JSON, letting your agent handle the heavy lifting of document parsing and OCR without manual data entry.

## Overview
- **Category:** artificial-intelligence
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_o7UzJZoz14EYCYOOWoapn6mPokmSJgmiLbhrr2qv/ai-agent-connect
- **Tags:** document-extraction, pdf-parsing, ocr, data-extraction, structured-data

## Description

You have a folder full of messy PDFs, scanned invoices, and Word docs, and you need the data out of them without typing it into a spreadsheet by hand. This Connector lets your agent do that work for you. You can point your AI client at a document via a URL or a local file, and it'll pull out the specific fields you need—like invoice numbers, tax totals, or contract dates—and hand them back as clean JSON. It's built to handle the layout variations that usually break standard OCR, like different forms from different vendors. When you find this in the Vinkius catalog, you're getting a way to turn a mountain of static files into a usable database. You can even set up reference documents to teach the system exactly what a perfect extraction looks like, or batch-convert your results into Excel or CSV files once you're done. It handles both synchronous requests for immediate answers and asynchronous processing for large backlogs, so you can choose the speed that fits your task.

## Tools

### classify_sync
Classify a document into a specific type immediately. This helps sort your files as soon as they are uploaded.

### create_configuration
Set up a new configuration for a specific document type. Use this to define which fields your agent should look for.

### delete_configuration
Delete an old configuration. Use this to clean up your document types when you no longer need them.

### extract_portfolio_from_url
Extract data from a portfolio document at a URL asynchronously. This is a specialized tool for financial portfolios.

### generate_portfolio_upload_url
Generate a pre-signed upload URL for portfolio extraction. Use this to let users upload large financial docs securely.

### generate_upload_url_with_config
Generate a pre-signed upload URL for async extraction using a specific config. This is great for high-volume workflows.

### get_configuration
Get a specific configuration. Use this to check the rules currently applied to a document type.

### list_configuration_versions
List versions of a configuration. This is useful for auditing how your extraction rules have changed.

### list_configurations
List configurations for a document type. Use this to see all the different ways you can parse a specific file.

### update_configuration
Update a configuration. Use this to tweak the fields your agent extracts from a document.

### update_document_type
Update a document type. This lets you rename or modify your document categories on the fly.

### create_document_type
Create a new document type in your library. This lets you organize different categories of files like 'Utilities' or 'Rent'.

### create_golden
Create a reference document to serve as a ground truth. It helps the system understand exactly how to parse a specific layout.

### delete_configuration_version
Delete a draft or unpublish a configuration version. This keeps your production environment clean.

### delete_document_type
Delete a document type from your list. Use this to manage your document library efficiently.

### delete_golden
Delete a reference document. Use this when you've updated your ground truth and no longer need the old one.

### extract_from_url_with_config
Extract data from a URL using a specific configuration asynchronously. This is perfect for processing large batches of web links.

### extract_from_url
Extract data from a document at a URL asynchronously. This lets your agent process files in the background.

### extract_sync_with_config
Extract data from a document using a specific config synchronously. Use this when you need the data back immediately.

### extract_sync
Extract data from a document provided as a Base64 string synchronously. This is the fastest way to get data from a local file.

### extract_text_from_golden
Extract all text lines and coordinates from a reference document. This helps you map out how your agent should read a page.

### generate_csv
Compile your JSON extractions into a CSV spreadsheet. This makes it easy to share the data with people who don't use your app.

### generate_excel
Compile your JSON extractions into an Excel spreadsheet. This is the best way to get data into a format for business teams.

### generate_upload_url
Generate a pre-signed upload URL for asynchronous extraction. Use this to start a background job for any document.

### get_auth_tokens
Generate a temporary authorization token for external reviewers. This lets others see your extractions without full access.

### get_configuration_version
Get a specific version of a configuration. This lets you track changes to your parsing rules over time.

### get_document_type
Get a specific document type. This helps you see the details of your current document categories.

### get_document
Retrieve extraction results by ID. Use this to fetch the specific data your agent just pulled from a file.

### get_extraction_statistics
Returns daily extraction coverage statistics. Use this to see how much work your agent is doing each day.

### get_golden
Get reference document metadata. Use this to see the details of your ground truth files.

### list_document_types
List all document types. This shows you every category of file your agent can currently handle.

### list_extractions
Retrieve a filtered, paginated list of past extractions. Use this to look back at previous work.

### list_goldens
List reference documents for a document type. This shows you all the ground truth files you have on file.

### publish_configuration
Publish a configuration version to an environment. Use this to push new parsing rules live.

### unassociate_golden
Unassociate a reference document from its configuration. Use this to swap out an old ground truth file.

### update_golden
Update reference document metadata. Use this to keep your ground truth files organized.

### classify_async
Classify a document into one of the document types asynchronously. This is best for sorting large batches of files.

## Prompt Examples

**Prompt:** 
```
I have a bunch of invoices in a folder. Can you extract the total amounts and due dates into a table?
```

**Response:** 
```
I've processed the invoices for you. Here is the summary of the extracted data:

| Invoice # | Total Amount | Due Date |
| :--- | :--- | :--- |
| INV-001 | $1,250.00 | Dec 15, 2023 |
| INV-002 | $450.25 | Jan 10, 2024 |
| INV-003 | $2,100.00 | Feb 01, 2024 |

All data has been extracted into a structured format.
```

**Prompt:** 
```
Look at this tax form URL and tell me the gross income.
```

**Response:** 
```
I've finished analyzing the tax form at the provided link. Here are the key details:

*   **Document Type:** 1099-INT
*   **Gross Income:** $54,200.00
*   **Tax Withheld:** $4,100.00
*   **Status:** Verified

Let me know if you need me to extract any other fields from this form.
```

**Prompt:** 
```
I need to turn these 20 extraction results into a CSV file for my team.
```

**Response:** 
```
I've compiled the extraction results from all 20 documents into a CSV file. You can download it here: `extractions_report_Jan_2024.csv`. 

The file includes the following columns:
- Document ID
- Vendor Name
- Total Amount
- Payment Status
- Extraction Date
```

## Capabilities

### Classify documents by type
Automatically sort incoming files into categories like invoices or tax forms.

### Convert extractions to CSV
Turn JSON data from multiple documents into a single spreadsheet file.

### Generate Excel spreadsheets
Export your extracted document data directly into an Excel file for your team.

### Track extraction coverage
Get daily statistics on how many documents your agent has processed.

### Create reference documents
Establish a ground truth for the AI to follow when parsing specific layouts.

### Generate pre-signed upload URLs
Create secure links for your agent to upload files for background processing.

## Use Cases

### Automated Invoice Processing
An accounts payable clerk uses the agent to scan a folder of 500 PDFs. The agent uses extract_sync to pull totals and dates into a clean JSON list.

### Tax Form Digitization
A tax professional points the agent at a URL of 1099 forms. The agent uses extract_from_url to pull gross income data into a database.

### Contract Data Extraction
A legal team uses create_golden to teach the agent their specific contract format. The agent then extracts parties and dates from hundreds of new files.

### Financial Portfolio Analysis
An analyst uses extract_portfolio_from_url to scan investment documents and get a structured summary of all assets in a single JSON object.

## Benefits

- Stop manual data entry by using extract_sync to turn PDFs into JSON immediately.
- Handle large backlogs of files at once using extract_from_url for background processing.
- Standardize your outputs for your team by using generate_csv or generate_excel to create spreadsheets.
- Improve your extraction accuracy by using create_golden to set clear standards for your agent.
- Monitor your daily progress with get_extraction_statistics to see exactly how much work is getting done.
- Automate your filing system by using classify_async to sort documents into folders as they arrive.

## How It Works

The bottom line is you stop copy-pasting data from documents and start getting structured JSON instantly.

1. Connect your Sensible API key to your AI client through the Vinkius marketplace.
2. Provide a document URL or a Base64 string to your agent for extraction.
3. Receive a structured JSON object containing all the specific data points you requested.

## Frequently Asked Questions

**Can Sensible MCP handle handwritten forms?**
Yes, it can. The Connector handles images and low-quality scans, making it suitable for handwritten notes or older, scanned documents.

**Does Sensible MCP work with Word files?**
Yes, it supports PDFs, images, and Word documents. You can pull structured data from any of these formats into JSON.

**How does Sensible MCP handle different layouts?**
It uses configurations to map specific fields. This means it doesn't matter if the 'Total' is at the top or bottom of the page; the agent knows where to look.

**Can I export the data to Excel?**
Yes, you can. The Connector includes tools to compile your extracted data directly into an Excel spreadsheet for easy sharing.

**Is Sensible MCP just for simple OCR?**
No, it's specifically for structured data extraction. While it uses OCR, its main job is to identify fields and turn them into usable data.

**How does Sensible MCP handle high volume?**
It handles high volume through asynchronous processing. You can provide a list of URLs, and the agent will process them in the background.

**Can I extract data from a document instantly if I have its Base64 representation?**
Yes! Use the `extract_sync` tool. Provide the document type and the Base64-encoded document bytes, and your agent will return the structured extraction results synchronously.

**How do I extract data from a document hosted at a public URL?**
You can use the `extract_from_url` tool. Simply provide the document type, the document URL, and the content type (e.g., application/pdf) to trigger an asynchronous extraction.

**Can I specify a custom configuration layout when extracting?**
Yes, you can target specific configurations by using the `extract_sync_with_config` or `extract_from_url_with_config` tools, which allow you to define the exact configuration name to use for parsing.