DynamoDB MCP Server Cursor IDE Setup 2026

How do you set up the DynamoDB MCP server in Cursor? Install awslabs.dynamodb-mcp-server (AWS's official package, run via uvx), point it at your AWS credentials with AWS_PROFILE and AWS_REGION, add it to ~/.cursor/mcp.json, and restart Cursor. Unlike most database MCP servers on this site, this one isn't primarily a query tool — its main job is data modeling: it walks through access-pattern analysis, generates a schema, validates it against a real DynamoDB Local instance, and can produce a type-safe repository layer from the result.

That's worth calling out up front because it changes what you should expect. If you want something that just runs Scan and Query against an existing table from chat, this server can do that as a side effect of validation, but it isn't built as a general-purpose DynamoDB query client. It's closer to a design partner for a NoSQL data model your team hasn't finalized yet, or a way to sanity-check one you have.

Prerequisites

Python 3.10 or newer (uv python install 3.10 if you don't have it)

uv, the package manager from Astral — this is how the server runs, via uvx

AWS credentials configured (a named profile or environment-variable credentials) with DynamoDB permissions

Docker or Podman, or a Java Runtime 17+, for the schema-validation tool specifically (it spins up DynamoDB Local)

Cursor IDE with MCP support

Step 1: Confirm Your AWS Credentials Work

Before touching Cursor, make sure the profile you're about to reference actually has DynamoDB access:

aws dynamodb list-tables --profile default --region us-west-2

If that errors out, fix the AWS side first — a broken MCP connection caused by bad credentials looks identical to a broken MCP connection caused by a config typo, and you'll waste time debugging the wrong layer.

Step 2: Add the Server to Cursor's MCP Config

Open ~/.cursor/mcp.json and add:

{
  "mcpServers": {
    "awslabs-dynamodb-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.dynamodb-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "AWS_PROFILE": "default",
        "AWS_REGION": "us-west-2"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Swap AWS_PROFILE and AWS_REGION for your own. On Windows, uvx isn't the entry point — use uv tool run instead:

{
  "mcpServers": {
    "awslabs-dynamodb-mcp-server": {
      "command": "uv",
      "args": ["tool", "run", "--from", "awslabs.dynamodb-mcp-server@latest", "awslabs.dynamodb-mcp-server.exe"],
      "env": { "FASTMCP_LOG_LEVEL": "ERROR" },
      "disabled": false
    }
  }
}

Step 3: Restart Cursor and Verify

Quit and reopen Cursor, then check View → Output → MCP for the server loading without errors. Test with:

Walk me through the DynamoDB data modeling process for an app that tracks orders, customers, and order line items.

If Cursor responds by asking about your access patterns instead of immediately drawing a schema, that's correct behavior — the modeling tool is designed to gather requirements first.

What the Server Actually Exposes

Eight tools, split across two jobs — designing new schemas and migrating existing relational ones:

Design a new schema:

dynamodb_data_modeling — runs the full requirements-gathering and access-pattern-analysis workflow, then proposes a single-table or multi-table design

dynamodb_data_model_validation — takes the resulting model, spins up DynamoDB Local (via Docker/Podman or the JRE), creates the tables, loads test data, and actually runs every access pattern against it to check the design works

dynamodb_data_model_schema_converter — turns a markdown-described model into structured JSON

dynamodb_data_model_schema_validator — validates that JSON before code generation

generate_resources — produces a CDK app that deploys the validated tables

generate_data_access_layer — generates a type-safe Python repository layer (needs pydantic>=2.0 and boto3>=1.38 in the target project)

compute_performances_and_costs — estimates RCU/WCU capacity and monthly cost for a given design and traffic pattern

Migrate from a relational source:

source_db_analyzer — extracts schema and relationship info from MySQL, PostgreSQL, SQL Server, or Oracle, as a starting point for redesigning the same data as DynamoDB access patterns

Practical Workflows

Designing a new table from scratch

I'm building a multi-tenant SaaS app. Main access patterns: get all
projects for a tenant, get all tasks for a project, get a single task
by ID, and list tasks assigned to a user across all their projects.
Run the DynamoDB data modeling tool against these patterns.

The tool will ask clarifying questions about read/write ratios and item sizes before proposing a design — answer those instead of skipping ahead, since the resulting single-table design depends on them.

Validating a design before you build anything

Here's my proposed DynamoDB schema [paste JSON]. Validate it against
DynamoDB Local and confirm all four access patterns actually work
as single queries, not scans.

This is the step most people skip when hand-rolling a DynamoDB design, and it's the one that catches "this pattern actually needs a Scan" before it's in production.

Migrating an existing Postgres schema

Analyze my Postgres orders/customers/line_items schema and propose
a DynamoDB single-table design that supports the same access patterns
we currently hit with joins.

Estimating cost before committing to a design

Compute the RCU/WCU and monthly cost for this table design at
50 reads/sec and 10 writes/sec average, with a 3x peak multiplier.

When This Setup Breaks

Validation tool hangs or times out. It needs Docker/Podman running (to launch DynamoDB Local as a container) or a Java 17+ runtime on PATH. If neither is available, the validation step fails silently rather than with an obvious "Docker not found" error — check docker ps works before assuming the MCP config itself is broken.

Generated code doesn't match your project's dependency versions. generate_data_access_layer assumes pydantic>=2.0 and boto3>=1.38. If your project pins older versions, the generated repository code may use APIs that don't exist yet in your installed packages — check pip show pydantic boto3 before running codegen, not after it fails to import.

"AccessDenied" errors that aren't about your MCP config at all. The server uses whatever AWS credentials AWS_PROFILE points to. If modeling and validation work but compute_performances_and_costs or table creation fails, the profile likely lacks a specific permission (cost estimation sometimes needs Cost Explorer or Pricing API access depending on how it's scoped) — check IAM before re-checking mcp.json.

When NOT to use this MCP server: if you already have a stable DynamoDB table and just want ad hoc read access from chat — say, "show me item X" — this is the wrong tool for that job. Its tools are modeling- and migration-focused; there's no lightweight get_item/query tool in the list above for casual data browsing.

Frequently Asked Questions

Q: Does this server let me query live data in an existing DynamoDB table?
A: Only indirectly, through the validation tool, which creates and queries a local DynamoDB Local instance to test a design — not your production table. For casual browsing of live data, use the AWS CLI or console directly; this server is built around modeling and migration, not general querying.

Q: What AWS permissions does the MCP server need?
A: At minimum, DynamoDB read/write access under whatever AWS_PROFILE you configure. If you use generate_resources to deploy the CDK stack it produces, that profile also needs whatever IAM permissions CDK deployment normally requires (CloudFormation, IAM role creation, DynamoDB table creation).

Q: Can it migrate an existing MySQL or Postgres database's schema to DynamoDB automatically?
A: It analyzes the source schema with source_db_analyzer and proposes a DynamoDB design based on relationships it finds, but "automatically" oversells it — relational-to-NoSQL migration is a design decision, not a mechanical translation, and the proposal still needs your access patterns to be meaningful. Treat the output as a strong first draft, not a final schema.

Q: Do I need Docker for basic data modeling, or just for validation?
A: Just for validation. dynamodb_data_modeling (the design/requirements-gathering tool) doesn't touch Docker at all — only dynamodb_data_model_validation, which spins up DynamoDB Local to actually test the design, needs a container runtime or JRE 17+.

Q: Is this an official AWS package, or a community project?
A: Official — it's published under the awslabs namespace on PyPI and lives in the awslabs/mcp GitHub repository alongside AWS's other open-source MCP servers, under an Apache 2.0 license.

Related Guides

AWS MCP Server: Cursor IDE Setup (2026)

MongoDB MCP Server: Cursor IDE Setup (2026)

Postgres MCP Server Setup Guide

Terraform MCP Server: Cursor IDE Setup (2026)

Best MCP Servers for Developers (2026)

---

DynamoDB MCP Server Cursor IDE Setup 2026: awslabs.dynamodb-mcp-server