Skip to content
ProductivityQuality Score: 46

Amazon Textract MCP Configuration

The Amazon Textract MCP configuration provides a hosted JSON schema that connects AI assistants — including Claude Desktop, Cursor, Windsurf, and VS Code Copilot — to the Amazon Textract API via the Model Context Protocol. This configuration maps 10 API endpoints as callable tools, including AnalyzeDocument, AnalyzeExpense, AnalyzeID, and more. No authentication credentials are needed — it works out of the box. The configuration is auto-generated from the Amazon Textract OpenAPI specification (v2018-06-27) and has a quality score of 46/99 (fair documentation coverage). Use the hosted URL below to auto-load this schema into any compatible MCP client.

Quick Specs Reference

AuthenticationNo Auth Required
Available Endpoints10 tools mapped
Integration Modeauto Generation

Hosted Config URL

Use this hosted URL in any client that supports remote MCP schema auto-loading.

https://mcpbridge.org/config/amazonaws-com-textract.json

One-Click Client Setup

Copy the configurations below to wire your local coding assistant directly.

Claude Desktop

claude_desktop_config.json
{
  "mcpServers": {
    "amazonaws-com-textract": {
      "command": "npx",
      "args": [
        "-y",
        "@mcp/amazonaws-com-textract"
      ],
      "env": {
        "AMAZON_TEXTRACT_API_KEY": "your_amazon_textract_api_key"
      }
    }
  }
}

Cursor & VS Code

MCP Server URL Setup
{
  "mcpServers": {
    "amazonaws-com-textract": {
      "url": "https://mcpbridge.org/config/amazonaws-com-textract.json"
    }
  }
}

Raw Configuration JSON

For local command line wrappers or dynamic shell bindings.

{
  "mcpServers": {
    "amazonaws-com-textract": {
      "command": "npx",
      "args": ["-y","@mcp/amazonaws-com-textract"],
      "env": {
      "AMAZON_TEXTRACT_API_KEY": "your_amazon_textract_api_key"
}
    }
  }
}

Required Environment Keys

Substitute these secrets inside your configuration directory environment definitions.

AMAZON_TEXTRACT_API_KEY
Replace your_amazon_textract_api_key with your secret key credential

Mapped Web APIs & Tools

The following routes will be exposed directly as protocol tools for the LLM.

POST/#X-Amz-Target=Textract.AnalyzeDocument

AnalyzeDocument

POST/#X-Amz-Target=Textract.AnalyzeExpense

AnalyzeExpense

POST/#X-Amz-Target=Textract.AnalyzeID

AnalyzeID

POST/#X-Amz-Target=Textract.DetectDocumentText

DetectDocumentText

POST/#X-Amz-Target=Textract.GetDocumentAnalysis

GetDocumentAnalysis

POST/#X-Amz-Target=Textract.GetDocumentTextDetection

GetDocumentTextDetection

POST/#X-Amz-Target=Textract.GetExpenseAnalysis

GetExpenseAnalysis

POST/#X-Amz-Target=Textract.GetLendingAnalysis

GetLendingAnalysis

POST/#X-Amz-Target=Textract.GetLendingAnalysisSummary

GetLendingAnalysisSummary

POST/#X-Amz-Target=Textract.StartDocumentAnalysis

StartDocumentAnalysis

Similar Configurations

Notion API

Create and manage Notion pages, databases, and blocks through your AI agent.

https://mcpbridge.org/config/notion.json

Linear API

Manage issues, projects, and workflows in Linear through your AI agent.

https://mcpbridge.org/config/linear.json

Platform API

The Platform API is a comprehensive RESTful interface provided by Ably, a leading provider of real-time messaging and presence infrastructure, designed to give developers granular, programmatic control over their Ably applications and resources. Its core capabilities extend beyond simple pub/sub messaging, enabling the management and inspection of channels, the retrieval and publishing of messages, the manipulation of presence state for users across those channels, and the configuration of push notification subscriptions. Typical use cases span enterprise and consumer applications where real-time functionality is critical, such as live activity feeds for e-commerce platforms, collaborative tools requiring synchronized state, multi-user gaming, real-time chat, and IoT device status monitoring. This API serves as the foundational control plane for any application built on the Ably ecosystem, allowing for dynamic, server-side orchestration of real-time behaviors. When exposed as tools via the Model Context Protocol (MCP) to an AI coding assistant like Claude Desktop, Cursor, or Cline, this API gains transformative value. It transitions from a static endpoint reference to an interactive, queryable system that an AI agent can leverage to understand, debug, and extend a developer's real-time infrastructure. The AI can perform live introspection of channel activity, diagnose presence synchronization issues, or audit message flow without requiring the developer to manually construct complex cURL commands or navigate dashboards. This integration effectively turns the AI into a knowledgeable collaborator with direct, safe access to the operational state of the real-time layer, significantly accelerating troubleshooting, prototyping, and implementation of features that interact with or rely upon the messaging backbone. In practice, a developer can instruct the AI agent to perform a variety of dynamic, context-aware tasks. For instance, one might ask, "AI agent, query the recent messages on the 'user-updates' channel and summarize the last ten status changes," enabling rapid analysis of event streams. Another directive could be, "AI agent, create a new, private channel named 'group-chat-123' and configure its presence history retention to 24 hours," automating infrastructure setup. The AI can also be tasked to "check all active presence members on the 'dashboard' channel to verify if the test user is connected" for debugging, or to "remove a spam message with ID 'msg_abc' from the 'announcements' channel" for moderation. Furthermore, the AI can facilitate push notification management with commands like, "AI agent, list all device subscriptions for the 'breaking-news' channel and remove any that haven't been active in over 30 days," thus maintaining a clean and effective push subscriber list. Security and proper configuration are paramount when deploying this MCP server. Although the API specification lists authentication as "None," this refers to the public REST spec; in practice, all calls require authentication via an Ably API key or token. Developers must follow the principle of least privilege by generating scoped API keys specifically for the AI assistant tool. Keys should be assigned only the capabilities necessary for the intended tasks—such as "subscribe" and "publish" for message reading, or "channel-details" for introspection—and assigned only to the required channels or namespaces. Environment variables should be used to manage these credentials, never hardcoded. It is critical to deploy this MCP server in a secure environment and consider that enabling write operations (POST/DELETE) grants the AI agent the ability to modify state; thus, such tools should be enabled judiciously, potentially limited to development or staging environments, and always with full audit logging enabled to track AI-initiated actions.

https://mcpbridge.org/config/ably-io-platform.json

Control API v1

The Control API v1, provided by Ably, is a comprehensive programmatic interface designed for the administrative management and automation of Ably’s real-time messaging infrastructure. It serves as the central nervous system for controlling core resources within an Ably account, enabling developers and platform engineers to dynamically provision and configure applications, manage authentication credentials (keys), organize message flow with namespaces, and establish operational rules. Its primary function is to transition infrastructure management from manual, dashboard-driven tasks to scalable, code-first operations. This makes it indispensable for enterprise use cases such as automated environment provisioning for development and testing, multi-tenant SaaS platforms requiring isolated customer channels, and large-scale IoT deployments where device groups (represented by namespaces) or security credentials (keys) must be managed programmatically in response to dynamic demand. The API currently operates in a Beta state, indicating it is feature-rich but subject to refinement based on developer feedback. When integrated as tools for an AI coding assistant via the Model Context Protocol (MCP), the Control API unlocks a powerful paradigm of infrastructure-as-conversation, dramatically accelerating development workflows and reducing context-switching. An AI agent, armed with these tools, becomes a co-pilot capable of directly querying and modifying your Ably topology based on natural language instructions. This transforms abstract architectural decisions into immediate, executable actions. For instance, a developer can instruct the AI to "list all applications in our account and generate a new API key scoped to the 'production' namespace for the payments service," bypassing manual dashboard navigation and potential configuration errors. The value lies in the AI's ability to understand context, chain operations (e.g., "find the app ID for 'user-service', then list its keys, and finally create a new key with read-only permissions"), and act as a contextual expert, thereby compressing development cycles and enhancing operational accuracy. Practical workflows enabled by this MCP server are numerous and directly impactful. An AI agent can perform dynamic resource auditing by querying all keys and their permissions to generate a security report, stating, "AI agent can query all keys to audit privilege distribution across namespaces." It can automate environment cleanup by instructing, "AI agent can delete all test namespaces older than 30 days to reduce clutter and costs." In a CI/CD pipeline context, a developer could prompt, "AI agent can create a temporary, restricted key for a staging environment and then revoke it after tests complete," ensuring ephemeral credentials and enforcing security hygiene. For multi-tenant management, the AI can handle customer onboarding by executing, "AI agent can create a new namespace for a new tenant, generate a scoped key, and provide the configuration details back to the provisioning system." Critical to the deployment of this API is the absence of a built-in authentication method, which mandates that developers implement and enforce robust security controls externally. Authentication and authorization must be rigorously applied, ideally using Ably API keys with the smallest possible set of privileges required for the specific task, adhering strictly to the principle of least privilege. For an MCP server integration, this means the server should be configured with a high-privilege key only in a secure, isolated backend environment, while exposing a minimal set of safe, well-vetted tools to the AI. Additional security best practices include using short-lived tokens where possible, enforcing IP allowlists on API keys, and meticulously logging all API actions for audit trails. Developers must treat the Control API as a powerful and sensitive management plane, where a misconfigured tool or overly broad permission could lead to significant operational or security incidents.

https://mcpbridge.org/config/ably-net-control.json