AWS MCP Servers Part 3: Build Smarter, Query Faster

From raw data to intelligent insights — How AWS MCP Servers are transforming AI/ML workflows and data engineering

Ajaykumar K V

AI Engineer | AWS Community Builder

Published Apr 23, 2026

Last modified Apr 23, 2026

Introduction

Welcome to Part 3 of our AWS MCP Servers series! In Part 1 we covered the foundational servers , and in Part 2 we explored infrastructure and deployment. Now we go deeper into the servers that power AI/ML workloads and data-driven applications.

This post covers two major categories:

AI & Machine Learning — Bedrock Knowledge Bases, Document Loader, AgentCore, SageMaker, and more
Data & Analytics — DocumentDB, DynamoDB, ElastiCache, Neptune, Aurora DSQL, Data Processing, S3 Tables, AppSync, and more

These servers don't just connect your AI assistant to AWS data services — they give it the intelligence to design schemas, query graphs, generate images, and orchestrate entire data pipelines through natural conversation.

The Shift: From Data Consumer to Data Collaborator

Traditional data workflow:

1
Developer → Write queries → Debug → Optimize → Repeat

AI-assisted data workflow with MCP:

1
Developer → Describe intent → AI designs schema + writes queries + optimizes → Review → Ship

The difference is context. These MCP servers give your AI assistant deep, service-specific knowledge — not just generic SQL help, but DynamoDB single-table design patterns, Neptune graph traversal strategies, and Bedrock RAG pipeline best practices.

AI & Machine Learning MCP Servers

1. Amazon Bedrock Knowledge Base Retrieval MCP Server

Connect your AI assistant directly to your enterprise knowledge

The Amazon Bedrock Knowledge Base Retrieval MCP Server bridges the gap between your AI coding assistant and your organization's private knowledge. Instead of your AI relying solely on its training data, it can now query your internal documentation, product manuals, support tickets, and any other content you've indexed in Amazon Bedrock Knowledge Bases — with full citation support.

How It Works

Amazon Bedrock Knowledge Bases use vector embeddings to store and retrieve information. This MCP server exposes those retrieval capabilities directly to your AI assistant, enabling Retrieval-Augmented Generation (RAG) workflows without writing a single line of retrieval code.

Key Features

Feature	Description
Knowledge Base Discovery	Find and explore all available KBs by name or tag
Natural Language Queries	Retrieve information using conversational queries
Citation Support	Every result includes source attribution
Data Source Filtering	Focus queries on specific data sources
Reranking	Improve relevance using Amazon Bedrock reranking models
Tag-Based Filtering	Control which KBs are accessible via mcp-multirag-kb tag

Available Tools

The server exposes exactly two tools:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Tool 1: Discover all knowledge bases and their data sources

ListKnowledgeBases()

# Returns: mapping of KB IDs → name, description, and data_sources list



# Tool 2: Query a knowledge base with natural language

QueryKnowledgeBases(

    query,                      # Natural language query string

    knowledge_base_id,          # KB ID from ListKnowledgeBases

    number_of_results=10,       # How many results to return

    data_source_ids=[],         # Optional: filter by specific data sources

    reranking=False,            # Optional: enable Bedrock reranking

    reranking_model_name="AMAZON"  # "AMAZON" or "COHERE"

)

# Returns: retrieved documents with content, source location, and relevance score

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  "mcpServers": {
    "awslabs.bedrock-kb-retrieval-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.bedrock-kb-retrieval-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR",
        "KB_INCLUSION_TAG_KEY": "mcp-multirag-kb",
        "BEDROCK_KB_RERANKING_ENABLED": "false"
      }
    }
  }
}

Prerequisites

At least one Amazon Bedrock Knowledge Base tagged with mcp-multirag-kb: true
IAM permissions for bedrock:Retrieve, bedrock:ListKnowledgeBases, bedrock:GetKnowledgeBase
For reranking: additional bedrock:Rerank and bedrock:InvokeModel permissions

Real-World Scenario: Internal Support Bot

The Problem: Your support team spends hours searching through internal wikis, runbooks, and past incident reports to answer customer questions.

Traditional Approach:

Search Confluence manually
Check Slack history
Ask a senior engineer
Hope the answer is documented somewhere

With Bedrock KB Retrieval MCP Server:

1
2
"What's our standard procedure for handling database connection pool exhaustion 

in our payment service?"

The server:

Queries your internal runbooks KB
Retrieves the most relevant procedures with citations
Returns grounded answers pointing to the exact source documents
Your AI assistant synthesizes a clear, actionable response

No hallucinations. No guessing. Just your own knowledge, surfaced instantly.

Real-World Scenario: Multi-KB Research

The Problem: You need to cross-reference product documentation, API specs, and compliance requirements to answer a complex technical question.

With Bedrock KB Retrieval MCP Server:

1
2
3
"Does our current API authentication implementation comply with our 

security policy requirements? Check both the API docs KB and the 

security policy KB."

The server calls ListKnowledgeBases to discover both KBs, then runs QueryKnowledgeBases against each with optional data source filtering — returning cited passages from both so your AI assistant can provide a comprehensive, grounded answer.

2. Document Loader MCP Server

Give your AI assistant eyes for any document format

The Document Loader MCP Server solves a common pain point: your AI assistant can read code and text, but what about that PDF architecture diagram, the Excel spreadsheet with requirements, or the PowerPoint deck from last quarter's planning session? This server handles all of it.

Supported Formats

Format	Tool	Notes
PDF	`read_document`	Full text extraction via pdfplumber
DOCX / DOC	`read_document`	Converts to markdown via markitdown
XLSX / XLS	`read_document`	Parses sheets, converts to markdown
PPTX / PPT	`read_document`	Extracts slide content
Images (PNG, JPG, GIF, BMP, TIFF, WEBP)	`read_image`	Loads for LLM visual analysis
Slides as Images	`extract_slides_as_images`	Extracts each slide as PNG

Available Tools

1
2
3
4
5
6
7
8
9
10
11
12
13
read_document(

    file_path: str,

    file_type: str   # 'pdf', 'docx', 'doc', 'xlsx', 'xls', 'pptx', 'ppt'

)



read_image(

    file_path: str   # PNG, JPG, GIF, BMP, TIFF, WEBP

)



extract_slides_as_images(

    file_path: str   # PPTX, PPT, or PDF

    # Requires LibreOffice + poppler-utils

)

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
{

  "mcpServers": {

    "awslabs.document-loader-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.document-loader-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR",

        "MAX_FILE_SIZE_MB": "50",

        "DOCUMENT_BASE_DIR": "/path/to/your/documents"

      }

    }

  }

}

Security Note

DOCUMENT_BASE_DIR restricts document access to a specific directory, preventing the AI from reading files outside your designated folder. Always set this in production environments.

Real-World Scenario: Requirements Analysis

The Problem: Your product manager just dropped a 40-page requirements PDF and a 15-slide PowerPoint into your project folder. You need to extract user stories and map them to technical tasks.

With Document Loader MCP Server:

1
2
"Read the requirements.pdf and architecture-overview.pptx in my project folder. 

Extract all user stories and create a technical task breakdown for each one."

The server:

Extracts full text from the PDF
Parses slide content from the PowerPoint
Your AI assistant synthesizes both into structured technical tasks

What used to take hours of manual reading now takes seconds.

Real-World Scenario: Data Analysis from Excel

The Problem: You have quarterly sales data in an Excel file with multiple sheets and need to understand trends.

With Document Loader MCP Server:

1
2
"Load the Q4-sales-data.xlsx file and analyze the revenue trends across 

all product categories. Identify the top 3 growth areas."

The server parses all sheets into markdown, and your AI assistant performs the analysis — no Python scripts, no manual data extraction needed.

3. AWS Bedrock AgentCore MCP Server

Build, deploy, and manage production AI agents from your IDE

The AWS Bedrock AgentCore MCP Server is one of the most powerful servers in the entire AWS MCP ecosystem. It gives your AI coding assistant comprehensive access to the Amazon Bedrock AgentCore platform — enabling you to design, deploy, and manage production-grade AI agents through natural conversation in your IDE.

What is AgentCore?

Amazon Bedrock AgentCore is a fully managed platform for deploying AI agents at scale. It handles the infrastructure complexity so you can focus on agent logic. The platform includes:

Key Features

Feature	Description
Documentation Search	Search curated AgentCore docs with ranked results
Full Doc Retrieval	Fetch complete documentation pages
Runtime Management	Deploy and manage agents in AgentCore Runtime
Memory Management	Configure short-term and long-term memory
Gateway Management	Deploy MCP Gateways for API-to-tool transformation
Browser Automation	25 cloud-based browser tools (no local browser needed)
Smart Caching	Efficient document caching for optimal performance

Available Tools

Documentation Tools:

1
2
search_agentcore_docs(query, k=5)   # Search with ranked results

fetch_agentcore_doc(uri)            # Get full documentation page

Management Tools:

1
2
3
manage_agentcore_runtime()          # Deploy/manage agents in Runtime

manage_agentcore_memory()           # Configure STM/LTM memory

manage_agentcore_gateway()          # Deploy MCP Gateways

Browser Automation (25 tools):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Session management

start_browser_session(timeout_seconds=300)

stop_browser_session(session_id)



# Navigation

browser_navigate(session_id, url)

browser_navigate_back(session_id)



# Observation

browser_snapshot(session_id)        # Accessibility tree

browser_take_screenshot(session_id)

browser_evaluate(session_id, script) # Execute JavaScript



# Interaction

browser_click(session_id, ref)

browser_type(session_id, ref, text)

browser_fill_form(session_id, ...)

browser_handle_dialog(session_id, ...)

Configuration

1
2
3
4
5
6
7
8
9
10
11
{

  "mcpServers": {

    "bedrock-agentcore-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.amazon-bedrock-agentcore-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    }

  }

}

Real-World Scenario: Deploying Your First Production Agent

The Problem: You've built a customer support agent locally, but deploying it to production with proper memory, monitoring, and scaling feels overwhelming.

With AgentCore MCP Server:

1
2
3
"I have a customer support agent built with LangChain. Help me deploy it 

to AgentCore Runtime with persistent memory so it remembers customer 

context across sessions, and set up observability for monitoring."

The server:

Searches AgentCore docs for deployment requirements
Guides you through the BedrockAgentCoreApp code pattern
Walks through the CLI deployment workflow (configure → launch → invoke → status)
Sets up AgentCore Memory with semantic memory for customer context
Configures observability for real-time monitoring

What used to require deep platform knowledge now happens through conversation.

Real-World Scenario: Browser Automation Agent

The Problem: You need an agent that can browse the web, extract data from competitor sites, and compile reports — all running in the cloud without a local browser.

With AgentCore MCP Server:

1
2
"Set up a browser automation workflow that navigates to our competitor's 

pricing page, extracts the pricing table, and formats it as a comparison report."

The server spins up an isolated Firecracker microVM browser session, navigates the page, extracts data using browser_evaluate, and returns structured results — no local browser installation, no Selenium setup, no infrastructure management.

Pro Tip: Use DuckDuckGo or Bing instead of Google for browser automation — Google blocks cloud browser IPs with CAPTCHAs.

High-Level Overview: Other AI & ML Servers

Amazon Q Index MCP Server
Enables AI assistants to search through your enterprise's Amazon Q index, providing access to your organization's indexed content for RAG-enhanced responses. Ideal for teams already using Amazon Q Business.

Amazon Q Business MCP Server
Provides an AI assistant interface for content ingested into Amazon Q Business, supporting anonymous access patterns. Useful for building customer-facing chatbots backed by your enterprise knowledge.

AWS Bedrock Custom Model Import MCP Server
Manages custom models imported into Amazon Bedrock for on-demand inference. Helps you track, configure, and invoke your fine-tuned or custom models through natural language.

Amazon SageMaker AI MCP Server
Focused specifically on managing SageMaker HyperPod clusters — AWS's purpose-built infrastructure for high-performance, distributed ML training. It provides two core tools: manage_hyperpod_stacks for deploying, describing, and deleting HyperPod clusters via CloudFormation, and manage_hyperpod_cluster_nodes for listing clusters, inspecting nodes, updating software, and batch-deleting nodes. The server runs read-only by default (--allow-write enables mutations) and is best used alongside the AWS API MCP Server and EKS MCP Server for full SageMaker coverage beyond HyperPod.

Data & Analytics MCP Servers

SQL & NoSQL Databases

5. Amazon DocumentDB MCP Server

MongoDB-compatible document operations with AI-powered querying

The Amazon DocumentDB MCP Server bridges your AI assistant and your DocumentDB clusters, enabling natural language database operations against your MongoDB-compatible document store. It's designed with a security-first approach — read-only by default, with write operations requiring explicit opt-in.

Key Features

Feature	Description
Connection Management	Establish and maintain connections to DocumentDB clusters
Schema Analysis	Analyze collection schemas by sampling documents
Aggregation Pipelines	Execute complex DocumentDB aggregation pipelines
Query Planning	Get execution plan explanations for operations
Read-Only Mode	Default security mode — write ops require `--allow-write`
TLS Support	Full SSL/TLS certificate support for secure connections

Available Tools

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Connection

connect(connection_string)          # Connect to cluster, returns connection_id

disconnect(connection_id)           # Close connection



# Database & Collection Management

listDatabases(connection_id)

getDatabaseStats(connection_id, database)

listCollections(connection_id, database)

getCollectionStats(connection_id, database, collection)

countDocuments(connection_id, database, collection, query={})

analyzeSchema(connection_id, database, collection)  # Sample-based schema analysis



# Document Operations (write ops need --allow-write)

find(connection_id, database, collection, query, limit)

aggregate(connection_id, database, collection, pipeline)

insert(connection_id, database, collection, documents)

update(connection_id, database, collection, filter, update)

delete(connection_id, database, collection, filter)



# Query Planning

explainOperation(connection_id, database, collection, operation)

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{

  "mcpServers": {

    "awslabs.documentdb-mcp-server": {

      "command": "uvx",

      "args": [

        "awslabs.documentdb-mcp-server@latest"

        // Add "--allow-write" to enable write operations

      ],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1",

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    }

  }

}

Real-World Scenario: Schema Discovery and Migration Planning

The Problem: You've inherited a DocumentDB cluster with undocumented collections and need to understand the data structure before migrating to a new schema.

With DocumentDB MCP Server:

1
2
3
"Connect to my DocumentDB cluster at docdb-cluster.cluster-xyz.us-east-1.docdb.amazonaws.com 

and analyze the schema of all collections in the 'orders' database. 

Identify any inconsistencies in document structure."

The server:

Connects to the cluster with TLS
Lists all collections in the orders database
Samples documents from each collection to infer schema
Reports field coverage, types, and structural inconsistencies

What used to require writing custom schema analysis scripts now happens in one prompt.

6. Amazon DynamoDB MCP Server

The expert DynamoDB data modeling assistant

The DynamoDB MCP Server is unlike any other database MCP server — it's not just a query interface. It's a full data modeling expert that guides you through the entire DynamoDB design process, from requirements gathering through schema validation, code generation, and cost analysis.

DynamoDB's single-table design patterns are notoriously difficult to get right. This server embeds expert-level knowledge to help you avoid the common pitfalls.

The Complete DynamoDB Workflow

Available Tools

1
2
3
4
5
6
7
8
9
10
11
12
13
# Data Modeling

dynamodb_data_modeling()                    # Expert modeling guidance

dynamodb_data_model_validation()            # Test against DynamoDB Local

source_db_analyzer()                        # Analyze existing MySQL/PostgreSQL/SQL Server/Oracle



# Schema & Code Generation

dynamodb_data_model_schema_converter()      # Convert model to schema.json

dynamodb_data_model_schema_validator()      # Validate schema for code gen

generate_data_access_layer()                # Generate type-safe Python code

generate_resources(resource_type="cdk")    # Generate CDK deployment app



# Cost Analysis

compute_performances_and_costs()            # Calculate RCU/WCU and monthly costs

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
{

  "mcpServers": {

    "awslabs-dynamodb-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.dynamodb-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR",

        "AWS_REGION": "us-east-1"

      }

    }

  }

}

Real-World Scenario: E-Commerce Data Model Design

The Problem: You're building an e-commerce platform and need a DynamoDB data model that efficiently handles products, orders, customers, and inventory — all in a single table.

Traditional Approach:

Read the DynamoDB best practices docs (hours)
Design the model (days)
Realize your access patterns don't work (after deployment)
Redesign (more days)

With DynamoDB MCP Server:

1
2
3
4
"Design a DynamoDB data model for my e-commerce application. 

I need to support: get customer by ID, list orders by customer, 

get order details, list products by category, check inventory by product. 

Expected load: 500 RPS reads, 50 RPS writes."

The server:

Gathers your access patterns through conversation
Designs an optimized single-table model with GSIs
Validates the model against DynamoDB Local
Calculates monthly costs (~$X for your load)
Generates type-safe Python repository classes
Creates a CDK app for deployment

Real-World Scenario: Relational to DynamoDB Migration

The Problem: You have an existing MySQL database and need to migrate to DynamoDB for better scalability.

With DynamoDB MCP Server:

1
2
"Analyze my MySQL database at my-rds-cluster.us-east-1.rds.amazonaws.com 

and help me design a DynamoDB data model that supports all my current access patterns."

The source_db_analyzer tool connects to your MySQL database (via RDS Data API), extracts schema and query patterns from Performance Schema, and feeds that analysis directly into the modeling workflow.

7. Amazon ElastiCache MCP Server

Complete ElastiCache control plane management

The Amazon ElastiCache MCP Server provides comprehensive control plane operations for managing your ElastiCache infrastructure. It covers serverless caches, replication groups, cache clusters, and includes built-in CloudWatch monitoring and cost analysis.

Important: This server manages the ElastiCache control plane (creating/configuring clusters). For data plane operations (reading/writing cache data), use the Valkey MCP Server or Memcached MCP Server.

Key Features

Feature	Description
Serverless Cache Management	Create, modify, delete serverless caches
Replication Group Operations	Full lifecycle management for Redis replication groups
Cache Cluster Operations	Manage traditional cache clusters
Jump Host Support	Create EC2 jump hosts for private VPC access
SSH Tunnel Generation	Auto-generate SSH tunnel commands
CloudWatch Integration	Get metrics and analyze logs
Cost Explorer	Analyze ElastiCache spending
Migration Support	Test and execute Redis-to-ElastiCache migrations
Read-Only Mode	`--readonly` flag for safe exploration

Available Tools (grouped by category)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Serverless Cache

create_serverless_cache(...)

describe_serverless_caches(...)

modify_serverless_cache(...)

create_jump_host_serverless_cache(...)    # EC2 jump host for VPC access

get_ssh_tunnel_command_serverless_cache(...)



# Replication Groups (Redis)

create_replication_group(...)

describe_replication_groups(...)

modify_replication_group(...)

test_migration(...)                       # Test Redis → ElastiCache migration

start_migration(...)

complete_migration(...)



# Cache Clusters

create_cache_cluster(...)

describe_cache_clusters(...)

modify_cache_cluster(...)



# Monitoring & Cost

get_metric_statistics(...)               # CloudWatch metrics

filter_log_events(...)                   # Search logs

get_cost_and_usage(...)                  # Cost analysis

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{

  "mcpServers": {

    "awslabs.elasticache-mcp-server": {

      "command": "uvx",

      "args": [

        "awslabs.elasticache-mcp-server@latest"

        // Add "--readonly" to restrict to read-only operations

      ],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1",

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    }

  }

}

Real-World Scenario: Redis Migration to ElastiCache

The Problem: You're running a self-managed Redis cluster on EC2 and need to migrate to ElastiCache for better reliability and managed operations.

With ElastiCache MCP Server:

1
2
3
"I have a Redis 7.0 cluster running on EC2 in us-east-1. 

Help me migrate it to ElastiCache with minimal downtime. 

The cluster has 50GB of data and handles 10,000 ops/sec."

The server:

Tests migration compatibility with test_migration
Creates the target ElastiCache replication group
Starts the migration process
Monitors progress via CloudWatch metrics
Completes the migration with complete_migration

8. Amazon Neptune MCP Server

Graph database queries through natural language

The Amazon Neptune MCP Server enables your AI assistant to query and explore graph databases using both openCypher and Gremlin query languages. Whether you're working with Neptune Database (property graphs) or Neptune Analytics (graph analytics), this server provides direct query execution and schema exploration.

Key Features

Feature	Description
openCypher Support	Execute Cypher queries (Neptune Database + Analytics)
Gremlin Support	Execute Gremlin traversals (Neptune Database)
Schema Retrieval	Get the graph schema as a text description
Status Check	Verify graph availability before querying
Flexible Endpoints	Supports both Neptune Database and Neptune Analytics

Available Tools

1
2
3
4
5
6
7
8
execute_query(

    query: str,           # openCypher or Gremlin query

    query_type: str       # "openCypher" or "gremlin"

)



get_schema()              # Returns graph schema as text



get_status()              # Check if graph is "Available" or "Unavailable"

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
{

  "mcpServers": {

    "Neptune Query": {

      "command": "uvx",

      "args": ["awslabs.amazon-neptune-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "INFO",

        "NEPTUNE_ENDPOINT": "neptune-db://your-cluster.cluster-xyz.us-east-1.neptune.amazonaws.com"

      }

    }

  }

}

For Neptune Analytics:

1
2
3
4
5
{

  "env": {

    "NEPTUNE_ENDPOINT": "neptune-graph://your-graph-id"

  }

}

Real-World Scenario: Fraud Detection Graph Analysis

The Problem: Your fraud detection system uses a Neptune graph to model relationships between accounts, transactions, and devices. You need to investigate a suspicious transaction cluster.

Traditional Approach:

1
2
3
4
5
MATCH (a:Account)-[:MADE]->(t:Transaction)-[:FROM]->(d:Device)

WHERE t.amount > 10000 AND t.timestamp > datetime('2026-01-01')

WITH a, collect(d) as devices

WHERE size(devices) > 3

RETURN a.id, size(devices) as device_count

(Writing this from scratch, debugging syntax, iterating...)

With Neptune MCP Server:

1
2
3
"Find all accounts that made transactions over $10,000 in January 2026 

from more than 3 different devices. Show me the account IDs and 

their transaction patterns."

The server:

Checks graph schema to understand the data model
Generates the appropriate openCypher query
Executes it against your Neptune cluster
Returns results for your AI assistant to analyze

Real-World Scenario: Knowledge Graph Exploration

The Problem: You have a knowledge graph of your product catalog with relationships between products, categories, suppliers, and customers. You need to find cross-selling opportunities.

With Neptune MCP Server:

1
2
"What products are frequently bought together by customers who also 

purchased our premium subscription? Show me the relationship paths."

The server translates this into a graph traversal query, executes it, and returns the relationship patterns — enabling your AI assistant to identify cross-selling opportunities from your actual graph data.

9. Amazon Aurora DSQL MCP Server

Distributed SQL with AI-powered query generation

The Aurora DSQL MCP Server connects your AI assistant to Amazon Aurora DSQL — AWS's distributed SQL database with PostgreSQL compatibility. It converts natural language into PostgreSQL-compatible SQL queries and includes built-in access to Aurora DSQL documentation and best practices.

Key Features

Feature	Description
Natural Language to SQL	Convert questions into PostgreSQL-compatible queries
Read-Only by Default	Safe exploration without accidental writes
Transaction Support	Execute multi-statement transactions
Schema Inspection	Retrieve table schema information
Built-in Documentation	Search and read DSQL docs directly
Best Practice Recommendations	Get DSQL-specific guidance
Connection Reuse	Efficient connection pooling between requests
AI Skills/Steering	Install DSQL-specific AI rules for better code generation

Available Tools

1
2
3
4
5
6
7
8
9
10
# Database Operations

readonly_query(sql)                     # Execute read-only SQL

transact(statements)                    # Execute in a transaction

                                        # (write ops need --allow-writes)

get_schema()                            # Retrieve table schema



# Documentation

dsql_search_documentation(search_phrase, limit=5)

dsql_read_documentation(url, start_index=0)

dsql_recommend(url)                     # Get best practice recommendations

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{

  "mcpServers": {

    "awslabs.aurora-dsql-mcp-server": {

      "command": "uvx",

      "args": [

        "awslabs.aurora-dsql-mcp-server@latest",

        "--cluster_endpoint", "01abc2ldefg3.dsql.us-east-1.on.aws",

        "--region", "us-east-1",

        "--database_user", "admin",

        "--profile", "default"

        // Add "--allow-writes" to enable write operations

      ],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    }

  }

}

Real-World Scenario: Multi-Region Application Analytics

The Problem: Your Aurora DSQL cluster spans multiple regions and you need to analyze user behavior data without writing complex SQL.

With Aurora DSQL MCP Server:

1
2
3
"Show me the top 10 most active users in the last 30 days, 

their average session duration, and which features they use most. 

Group by user tier."

The server:

Inspects your schema to understand the table structure
Generates optimized PostgreSQL-compatible SQL
Executes the query against your DSQL cluster
Returns results for analysis

DSQL AI Skills

A unique feature of the Aurora DSQL MCP Server is its AI Skills system — installable steering rules that give your AI assistant deep DSQL-specific knowledge:

1
2
# Install DSQL skills for your coding assistant

npx skills add awslabs/mcp --skill dsql

This installs DSQL best practices, patterns, and guidance directly into your AI assistant's context — improving code generation quality for DSQL-specific scenarios.

High-Level Overview: Other Database Servers

Amazon ElastiCache/MemoryDB for Valkey MCP Server
Provides data plane operations for Valkey-compatible caches — advanced data structures, pub/sub, streams, and more. Use this alongside the ElastiCache MCP Server when you need to read/write cache data.

Amazon ElastiCache for Memcached MCP Server
High-speed caching operations using the Memcached protocol. Ideal for simple key-value caching scenarios where Memcached's simplicity is preferred over Redis/Valkey's feature set.

Amazon Timestream for InfluxDB MCP Server
Time-series database operations for IoT, metrics, and monitoring data. Supports InfluxDB-compatible queries for teams already familiar with the InfluxDB ecosystem.

Amazon Keyspaces MCP Server
Apache Cassandra-compatible operations for wide-column data. Useful for teams migrating from Cassandra or building applications that need Cassandra's data model with AWS managed infrastructure.

Amazon Aurora MySQL MCP Server
MySQL database operations via RDS Data API. Converts natural language to MySQL-compatible SQL and executes against your Aurora MySQL clusters — no connection string management needed.

Amazon Aurora Postgres MCP Server
PostgreSQL database operations via RDS Data API. Same natural language to SQL conversion for Aurora PostgreSQL clusters, with full PostgreSQL dialect support.

Analytics & Processing MCP Servers

10. AWS Data Processing MCP Server

Your AI co-pilot for Glue, EMR, and Athena workflows

The AWS Data Processing MCP Server is one of the most comprehensive servers in the entire AWS MCP ecosystem. It covers the full data engineering lifecycle across three major AWS services: AWS Glue (ETL and data catalog), Amazon EMR (big data processing), and Amazon Athena (serverless SQL analytics).

If you work with data pipelines, this server transforms how you interact with your data infrastructure.

Coverage Overview

Key Capabilities

AWS Glue:

Data Catalog management (databases, tables, partitions, connections)
ETL job creation with automatic script generation
Crawler management for automated data discovery
Interactive Spark/Ray sessions for development
Workflow and trigger orchestration
Security configurations and encryption settings

Amazon EMR:

Cluster lifecycle management (create, configure, terminate)
Instance fleet and group management (on-demand + spot)
Step execution for Hadoop, Spark, and other jobs
EMR Serverless application management
Security configuration management

Amazon Athena:

SQL query execution and result retrieval
Named query management (save and reuse queries)
Data catalog operations (LAMBDA, GLUE, HIVE, FEDERATED)
Workgroup administration for cost control

Available Tools (selected highlights)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# Glue Data Catalog

manage_aws_glue_databases(operation, ...)

manage_aws_glue_tables(operation, ...)

manage_aws_glue_crawlers(operation, ...)



# Glue ETL

manage_aws_glue_jobs(operation, ...)      # create, run, monitor jobs

manage_aws_glue_sessions(operation, ...)  # interactive Spark sessions

manage_aws_glue_workflows(operation, ...)



# EMR

manage_aws_emr_clusters(operation, ...)

manage_aws_emr_ec2_steps(operation, ...)

manage_aws_emr_serverless_applications(operation, ...)

manage_aws_emr_serverless_job_runs(operation, ...)



# Athena

manage_aws_athena_query_executions(operation, ...)

manage_aws_athena_named_queries(operation, ...)

manage_aws_athena_workgroups(operation, ...)



# Supporting Tools

create_data_processing_role(service_type)  # Create IAM roles for Glue/EMR/Athena

upload_to_s3(bucket, key, content)         # Upload scripts to S3

analyze_s3_usage_for_data_processing()     # Identify idle buckets

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{

  "mcpServers": {

    "aws.dp-mcp": {

      "command": "uvx",

      "args": [

        "awslabs.aws-dataprocessing-mcp-server@latest",

        "--allow-write",

        "--allow-sensitive-data-access"

      ],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR",

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1"

      }

    }

  }

}

Real-World Scenario: Building an ETL Pipeline from Scratch

The Problem: You need to build a data pipeline that ingests raw CSV files from S3, transforms them, and loads the results into a data warehouse — but you're new to AWS Glue.

Traditional Approach:

Learn Glue concepts (days)
Write PySpark transformation scripts
Configure crawlers manually
Set up workflows and triggers
Debug job failures
Optimize for cost

With Data Processing MCP Server:

1
2
3
4
"I have raw sales CSV files landing in s3://my-bucket/raw/sales/ daily. 

I need to clean the data (remove nulls, standardize dates), join with 

customer data from my RDS database, and load results to s3://my-bucket/processed/. 

Set up a complete Glue ETL pipeline that runs every night at 2 AM."

The server:

Creates IAM roles with appropriate permissions
Sets up a Glue crawler to catalog the raw data
Generates PySpark transformation script
Creates the Glue ETL job with the script uploaded to S3
Configures a Glue workflow with a scheduled trigger
Sets up CloudWatch monitoring

Real-World Scenario: Ad-Hoc Analytics with Athena

The Problem: Your business team needs quick answers from your data lake, but they don't know SQL and you don't want to give them direct database access.

With Data Processing MCP Server:

1
2
"Query our sales data in Athena. Show me total revenue by product category 

for Q1 2026, compared to Q1 2025. Include the percentage change."

The server:

Discovers available databases and tables in the Glue Data Catalog
Generates the appropriate SQL with year-over-year comparison
Executes the query in the appropriate Athena workgroup
Returns results with cost statistics

11. AWS S3 Tables MCP Server

Conversational analytics over S3-based table storage

The AWS S3 Tables MCP Server enables AI-powered management and querying of S3 Tables — AWS's optimized storage format for tabular data built on Apache Iceberg. It's designed for analytics workloads where you need efficient, scalable table storage directly in S3.

Key Features

Feature	Description
Table Bucket Management	Create and list S3 Table Buckets
Namespace Management	Organize tables with logical namespaces
Table Management	Create, rename, and list tables
SQL Query Support	Run read-only SQL queries against S3 Tables
CSV to Table Conversion	Auto-create tables from CSV files in S3
Metadata Discovery	Access schema and storage metadata
Policy Management	View resource policies for access control
Read-Only by Default	Write ops require `--allow-write` flag

Available Tools

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Bucket & Namespace Management

list_table_buckets()

create_table_bucket(name)               # Requires --allow-write

list_namespaces(bucket)

create_namespace(bucket, namespace)     # Requires --allow-write



# Table Operations

list_tables(bucket, namespace)

create_table(bucket, namespace, name)   # Requires --allow-write

rename_table(...)

get_table_metadata(bucket, namespace, table)



# Data Operations

execute_sql_query(query)                # Read-only SQL

append_data(...)                        # Insert only, requires --allow-write

create_table_from_csv(s3_uri)          # Auto-create from CSV



# Metadata

get_maintenance_configuration(...)

get_resource_policy(...)

discover_s3_metadata_table(bucket)

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{

  "mcpServers": {

    "awslabs.s3-tables-mcp-server": {

      "command": "uvx",

      "args": [

        "awslabs.s3-tables-mcp-server@latest"

        // Add "--allow-write" to enable create/append operations

      ],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1"

      }

    }

  }

}

Real-World Scenario: Data Lake Analytics

The Problem: You have CSV files from multiple data sources landing in S3 and need to set up a queryable table structure for analytics.

With S3 Tables MCP Server:

1
2
3
"I have customer transaction data in s3://my-data-lake/transactions/data.csv. 

Create an S3 Table from this file and run a query to show me the top 

10 customers by total spend in the last 90 days."

The server:

Creates an S3 Table from the CSV file automatically
Infers the schema from the CSV headers
Executes the SQL query against the new table
Returns results immediately

No Glue crawlers, no Athena table definitions, no manual schema setup.

Real-World Scenario: Metadata Governance

The Problem: Your data governance team needs to audit all S3 Tables in your account — schemas, policies, and maintenance configurations.

With S3 Tables MCP Server:

1
2
"List all table buckets and their namespaces. For each table, 

show me the schema, resource policy, and maintenance configuration."

The server traverses your entire S3 Tables hierarchy and returns a comprehensive inventory — perfect for governance audits and documentation.

12. AWS AppSync MCP Server

GraphQL API management through natural language

The AWS AppSync MCP Server simplifies the management of GraphQL APIs built on AWS AppSync. It provides capabilities to create and manage GraphQL APIs, data sources, resolvers, and other AppSync resources through natural language interactions.

Key Features

Feature	Description
GraphQL API Management	Create and configure AppSync APIs
Data Source Management	Connect DynamoDB, Lambda, RDS, HTTP, and more
Resolver Management	Create and update resolvers with mapping templates
Schema Management	Define and update GraphQL schemas
API Key Management	Create and manage API authentication keys
Function Management	Manage AppSync pipeline functions

Available Tools

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# API Management

create_graphql_api(name, auth_type, ...)

list_graphql_apis()

get_graphql_api(api_id)

update_graphql_api(api_id, ...)

delete_graphql_api(api_id)



# Schema

get_schema(api_id)

start_schema_creation(api_id, definition)



# Data Sources

create_data_source(api_id, name, type, ...)  # DynamoDB, Lambda, RDS, HTTP, None

list_data_sources(api_id)

update_data_source(api_id, name, ...)



# Resolvers

create_resolver(api_id, type_name, field_name, ...)

list_resolvers(api_id, type_name)

update_resolver(api_id, type_name, field_name, ...)



# API Keys

create_api_key(api_id, description, expires)

list_api_keys(api_id)

Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
{

  "mcpServers": {

    "awslabs.appsync-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.appsync-mcp-server@latest"],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1",

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    }

  }

}

Real-World Scenario: Building a GraphQL API for a Mobile App

The Problem: You need to build a GraphQL API for a mobile app that queries user profiles, posts, and comments from DynamoDB.

With AppSync MCP Server:

1
2
3
4
"Create an AppSync GraphQL API for my social media app. 

I need types for User, Post, and Comment. 

Connect it to my DynamoDB tables and set up resolvers 

for getting a user's posts and a post's comments."

The server:

Creates the AppSync API with Cognito authentication
Defines the GraphQL schema with User, Post, Comment types
Creates DynamoDB data sources for each table
Sets up resolvers with appropriate mapping templates
Returns the API endpoint URL

Real-World Scenario: Real-Time Subscriptions

The Problem: Your app needs real-time updates when new comments are posted, but you're not sure how to set up AppSync subscriptions.

With AppSync MCP Server:

1
2
"Add a real-time subscription to my AppSync API so mobile clients 

get notified when new comments are added to a post they're viewing."

The server adds the subscription type to your schema and configures the resolver — enabling real-time WebSocket-based updates without managing WebSocket infrastructure.

High-Level Overview: Other Analytics & Processing Servers

Amazon Redshift MCP Server
Provides tools to discover, explore, and query Amazon Redshift clusters and serverless workgroups. Enables AI assistants to interact with your data warehouse safely — from schema discovery through complex analytical queries.

AWS IoT SiteWise MCP Server
Comprehensive industrial IoT asset management and analytics. Covers asset model creation, data ingestion, monitoring, and analytics for industrial workloads. Ideal for manufacturing and operational technology teams.

Amazon SageMaker Unified Studio MCP (Spark Troubleshooting)
A fully managed remote MCP server for troubleshooting Apache Spark applications on EMR, Glue, and SageMaker Notebooks. Provides automated workload analysis and intelligent code recommendations for Spark issues.

Production Scenarios: Putting It All Together

Scenario 1: Building an Intelligent Customer Support System

Challenge: Build a support system that answers customer questions using your internal knowledge base, logs conversations to DynamoDB, and generates visual reports.

MCP Servers Used:

Bedrock KB Retrieval MCP Server (knowledge retrieval)
DynamoDB MCP Server (conversation storage)
Nova Canvas / Bedrock Image MCP Server (report visualization)
Document Loader MCP Server (ingest new documentation)

Conversation Flow:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
You: "Build a customer support system that:

     1. Answers questions from our product documentation KB

     2. Stores conversation history in DynamoDB

     3. Generates weekly summary reports with charts"



AI: [Uses KB Retrieval MCP to query product documentation]

    [Uses DynamoDB MCP to design conversation storage schema]

    [Uses Nova Canvas MCP to generate sample report visualizations]

    

    "Here's the architecture:

    - Bedrock KB retrieval for grounded answers with citations

    - DynamoDB single-table design for conversation history

      (partition key: customerId, sort key: timestamp)

    - Weekly Lambda function generates summary stats

    - Nova Canvas creates visual charts for the report

    

    Generated the DynamoDB schema, Python DAL code, and 

    sample report visualization. Ready to deploy?"

Scenario 2: Data Lake Modernization

Challenge: Migrate a legacy data warehouse to a modern S3-based data lake with automated ETL and self-service analytics.

MCP Servers Used:

Data Processing MCP Server (Glue ETL + Athena)
S3 Tables MCP Server (table management)
DocumentDB MCP Server (source data analysis)
Aurora DSQL MCP Server (target analytics queries)

Conversation Flow:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
You: "Modernize our data infrastructure:

     - Source: DocumentDB with 50 collections

     - Target: S3 Tables for analytics

     - Need: Daily ETL, self-service SQL queries"



AI: [Uses DocumentDB MCP to analyze source schemas]

    [Uses Data Processing MCP to create Glue crawlers and ETL jobs]

    [Uses S3 Tables MCP to set up table structure]

    [Uses Aurora DSQL MCP to validate query patterns]

    

    "Migration plan:

    - Analyzed 50 DocumentDB collections, identified 12 core entities

    - Created Glue crawlers for automated schema discovery

    - Generated ETL jobs for each entity with transformation logic

    - Set up S3 Tables with Iceberg format for time-travel queries

    - Configured Athena workgroups for team-based cost control

    

    Estimated daily ETL cost: $X | Query cost: $Y per TB scanned"

Scenario 3: AI Agent Platform Setup

Challenge: Deploy a production AI agent that can browse the web, remember user preferences, and execute code — all managed through your IDE.

MCP Servers Used:

AgentCore MCP Server (agent deployment + browser automation)
Bedrock KB Retrieval MCP Server (agent knowledge)
ElastiCache MCP Server (session caching)

Conversation Flow:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
You: "Deploy a research agent that:

     - Browses the web to gather information

     - Remembers user research preferences

     - Caches results for 24 hours

     - Runs in production with monitoring"



AI: [Uses AgentCore MCP to set up Runtime deployment]

    [Uses AgentCore browser tools to test web navigation]

    [Uses AgentCore Memory MCP to configure semantic memory]

    [Uses ElastiCache MCP to create serverless cache for results]

    

    "Agent deployed:

    - AgentCore Runtime: serverless, auto-scaling

    - Memory: semantic LTM for user preferences, STM for session context

    - Browser: isolated Firecracker microVM sessions

    - ElastiCache serverless cache: 24h TTL for research results

    - Observability: real-time tracing via AgentCore Observability

    

    Agent endpoint: https://agent-id.bedrock-agentcore.us-east-1.amazonaws.com"

Quick Reference: Which Server to Use?

Use Case	Recommended Server(s)
Query enterprise knowledge bases	Bedrock KB Retrieval MCP Server
Parse PDFs, Excel, PowerPoint files	Document Loader MCP Server
Generate images from text	Bedrock Image MCP Server
Deploy and manage AI agents	AgentCore MCP Server
ML model management	SageMaker AI MCP Server
MongoDB-compatible document queries	DocumentDB MCP Server
DynamoDB schema design + code gen	DynamoDB MCP Server
ElastiCache cluster management	ElastiCache MCP Server
Graph database queries	Neptune MCP Server
Distributed SQL analytics	Aurora DSQL MCP Server
Glue ETL + EMR + Athena pipelines	Data Processing MCP Server
S3-based table analytics	S3 Tables MCP Server
GraphQL API management	AppSync MCP Server

Recommended Configuration for AI/ML + Data Teams

Here's a comprehensive configuration for teams working across AI/ML and data workloads:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
{

  "mcpServers": {

    "awslabs.bedrock-kb-retrieval-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.bedrock-kb-retrieval-mcp-server@latest"],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1",

        "KB_INCLUSION_TAG_KEY": "mcp-multirag-kb",

        "BEDROCK_KB_RERANKING_ENABLED": "false",

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    },

    "awslabs.document-loader-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.document-loader-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR",

        "MAX_FILE_SIZE_MB": "50",

        "DOCUMENT_BASE_DIR": "/path/to/your/documents"

      }

    },

    "bedrock-agentcore-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.amazon-bedrock-agentcore-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    },

    "awslabs-dynamodb-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.dynamodb-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR",

        "AWS_REGION": "us-east-1"

      }

    },

    "awslabs.documentdb-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.documentdb-mcp-server@latest"],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1",

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    },

    "awslabs.elasticache-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.elasticache-mcp-server@latest", "--readonly"],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1",

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    },

    "Neptune Query": {

      "command": "uvx",

      "args": ["awslabs.amazon-neptune-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "INFO",

        "NEPTUNE_ENDPOINT": "neptune-db://your-cluster.us-east-1.neptune.amazonaws.com"

      }

    },

    "awslabs.aurora-dsql-mcp-server": {

      "command": "uvx",

      "args": [

        "awslabs.aurora-dsql-mcp-server@latest",

        "--cluster_endpoint", "your-cluster.dsql.us-east-1.on.aws",

        "--region", "us-east-1",

        "--database_user", "admin"

      ],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR"

      }

    },

    "aws.dp-mcp": {

      "command": "uvx",

      "args": ["awslabs.aws-dataprocessing-mcp-server@latest"],

      "env": {

        "FASTMCP_LOG_LEVEL": "ERROR",

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1"

      }

    },

    "awslabs.s3-tables-mcp-server": {

      "command": "uvx",

      "args": ["awslabs.s3-tables-mcp-server@latest"],

      "env": {

        "AWS_PROFILE": "your-profile",

        "AWS_REGION": "us-east-1"

      }

    }

  }

}

Summary

In this third part of our AWS MCP Servers series, we explored the servers that power AI/ML workloads and data-driven applications:

Category	Servers Covered (Deep Dive)	Key Capability
AI & Machine Learning	Bedrock KB Retrieval, Document Loader, Nova Canvas, AgentCore	RAG pipelines, document parsing, image generation, agent deployment
Databases	DocumentDB, DynamoDB, ElastiCache, Neptune, Aurora DSQL	Natural language queries, expert schema design, graph traversal
Analytics & Processing	Data Processing, S3 Tables, AppSync	ETL pipelines, table analytics, GraphQL API management

The common thread across all these servers: they don't just expose APIs — they bring domain expertise. The DynamoDB server knows single-table design patterns. The AgentCore server knows how to deploy production agents. The Data Processing server knows how to build Glue ETL pipelines. That expertise, combined with your AI assistant's reasoning, is what makes these servers genuinely transformative.

Thank you so much for reading all the way through! I know this was a long one, but I hope every section was worth your time. If this helped you understand even one of these MCP servers better, that's exactly why I wrote it. If you have questions, feedback, or real-world scenarios you'd like me to cover in the next part — I'd love to hear from you. See you in Part 4! 🙌

Resources

GitHub Repository: github.com/awslabs/mcp
Documentation Site: awslabs.github.io/mcp
Bedrock Knowledge Bases: docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html
AgentCore Documentation: docs.aws.amazon.com/bedrock-agentcore/latest/devguide/mcp-getting-started.html
DynamoDB Best Practices: docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html
Model Context Protocol: modelcontextprotocol.io

# agentic-ai # agentic-interactions # kiro # mcp # mcp-server

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.

Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article

Builder Center

AWS MCP Servers Part 3: Build Smarter, Query Faster

Ajaykumar K V

Introduction

The Shift: From Data Consumer to Data Collaborator

AI & Machine Learning MCP Servers

1. Amazon Bedrock Knowledge Base Retrieval MCP Server

How It Works

Key Features

Available Tools

Configuration

Prerequisites

Real-World Scenario: Internal Support Bot

Real-World Scenario: Multi-KB Research

2. Document Loader MCP Server

Supported Formats

Available Tools

Configuration

Security Note

Real-World Scenario: Requirements Analysis

Real-World Scenario: Data Analysis from Excel

3. AWS Bedrock AgentCore MCP Server

What is AgentCore?

Key Features

Available Tools

Configuration

Real-World Scenario: Deploying Your First Production Agent

Real-World Scenario: Browser Automation Agent

High-Level Overview: Other AI & ML Servers

Data & Analytics MCP Servers

SQL & NoSQL Databases

5. Amazon DocumentDB MCP Server

Key Features

Available Tools

Configuration

Real-World Scenario: Schema Discovery and Migration Planning

6. Amazon DynamoDB MCP Server

The Complete DynamoDB Workflow

Available Tools

Configuration

Real-World Scenario: E-Commerce Data Model Design

Real-World Scenario: Relational to DynamoDB Migration

7. Amazon ElastiCache MCP Server

Key Features

Available Tools (grouped by category)

Configuration

Real-World Scenario: Redis Migration to ElastiCache

8. Amazon Neptune MCP Server

Key Features

Available Tools

Configuration

Real-World Scenario: Fraud Detection Graph Analysis

Real-World Scenario: Knowledge Graph Exploration

9. Amazon Aurora DSQL MCP Server

Key Features

Available Tools

Configuration

Real-World Scenario: Multi-Region Application Analytics

DSQL AI Skills

High-Level Overview: Other Database Servers

Analytics & Processing MCP Servers

10. AWS Data Processing MCP Server

Coverage Overview

Key Capabilities

Available Tools (selected highlights)

Configuration

Real-World Scenario: Building an ETL Pipeline from Scratch

Real-World Scenario: Ad-Hoc Analytics with Athena

11. AWS S3 Tables MCP Server

Key Features

Available Tools

Configuration

Real-World Scenario: Data Lake Analytics

Real-World Scenario: Metadata Governance

12. AWS AppSync MCP Server

Key Features

Available Tools

Configuration

Real-World Scenario: Building a GraphQL API for a Mobile App

Real-World Scenario: Real-Time Subscriptions