Spark
Sign In
MCP Connector

Query and manage DynamoDB tables using natural language

MCPToolkit adds DynamoDB-Toolbox query, get, put, and delete tools to an MCP server for natural-language table access.

Get from source
Works with dynamodbclaudecursor
dynamodb-toolbox/dynamodb-toolbox
Own this? Claim it
79
Spark score
out of 100
Updated 10 days ago
Source checked Sep 12, 2026
Version 2.10.7
Add to Favorites

Why it matters

Enable AI assistants like Claude and Cursor to interact with DynamoDB tables through natural language by exposing database operations as MCP tools with automatic validation, formatting, and schema documentation.

Outcomes

What it gets done

01

Retrieve entity items from DynamoDB tables using registered access patterns

02

Insert new entity items into DynamoDB with automatic validation and defaults

03

Delete entity items from DynamoDB tables through natural language commands

04

Query database items using access patterns with LLM-friendly schema descriptions

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Capabilities

Tools your agent gets

ddb-tb_use-access-pattern-on-table

Query items from the database using a registered AccessPattern.

ddb-tb_get-entity-item-from-table

Retrieve an entity item from the DynamoDB database.

ddb-tb_put-entity-item-in-table

Insert an entity item into the DynamoDB database.

ddb-tb_delete-entity-item-from-table

Delete an entity item from the DynamoDB database.

Overview

DynamoDB-Toolbox

MCPToolkit is a DynamoDB-Toolbox utility that registers DynamoDB query, get, put, and delete operations as tools on an MCP server. It builds tool names from your table and entity names, and can run in a readonly mode that removes the write and delete tools. Adding title and description metadata to your tables, entities, and attributes improves how the tools are understood by an LLM client. Use it when you already have an MCP server and a DynamoDB-Toolbox schema and want AI clients to query or update DynamoDB data without hand-writing query code. Enable readonly mode when write access needs to be off by default rather than relying on client-side restraint.

What it does

MCPToolkit is a DynamoDB-Toolbox utility that adds DynamoDB querying and mutation tools to an MCP server, so any MCP client can interact with your DynamoDB tables using natural language. Build it against your database with PokeDB.build(MCPToolkit), then call mcpToolkit.addTools(server) and it registers a set of tools scoped to your database's tables, entities, and registered access patterns.

For each registered AccessPattern it exposes a ddb-tb_use-<KEY>-access-pattern-on-<TABLE>-table tool for querying. For each entity it exposes ddb-tb_get-${entityName}-item-from-${dbTableKey}-table to retrieve an item, ddb-tb_put-${entityName}-item-in-${dbTableKey}-table to insert one, and ddb-tb_delete-${entityName}-item-from-${dbTableKey}-table to delete one. All of the generated tools automatically apply DynamoDB-Toolbox's own validation, default values, links, and encoding/decoding/formatting.

When to use - and when NOT to

Use MCPToolkit when you already have an MCP server and a DynamoDB-Toolbox schema (tables, entities, and access patterns) and want to expose that schema to an MCP client without hand-writing bespoke query tools. Do NOT assume write access is restricted by default: the put and delete tools are generated automatically, so any client with normal access can insert or delete items unless you explicitly opt into readonly mode.

Capabilities

  • Query tools for every registered AccessPattern, one per table/key combination.
  • Entity-level get, put, and delete tools, named after the entity and table.
  • A readonly option (mcpToolkit.addTools(server, { readonly: true })) that removes the put and delete tools, leaving only get and query operations.
  • Automatic validation, default values, links, and encoding/decoding/formatting on every generated tool, inherited from the underlying DynamoDB-Toolbox schema.
  • Better LLM-facing documentation when you add title/description metadata to your Tables, Entities, Access Patterns, and individual schema attributes (via the meta property, enriched through ZodSchemer for attribute-level descriptions).

How to install

The toolkit depends on zod and @modelcontextprotocol/sdk:

npm install zod @modelcontextprotocol/sdk

After installing, build the toolkit against your database with PokeDB.build(MCPToolkit) and call mcpToolkit.addTools(server) on an existing McpServer instance to register the tools; pass { readonly: true } as a second argument to expose only the get and query tools.

Who it's for

Teams already using DynamoDB-Toolbox to model their DynamoDB tables and entities who want to give an MCP-compatible AI client, such as Claude or Cursor, natural-language read and write access to that data, with an explicit readonly switch for cases where write access should stay off.

Source README

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

MCPToolkit

:::note

MCPToolkit requires the zod and @modelcontextprotocol/sdk dependencies to be installed first:

npm install zod @modelcontextprotocol/sdk

:::

A utility for quickly adding Tools to an MCP Server, enabling any MCP Clients (like Claude or Cursor) to interact with your DynamoDB Tables using natural language.

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { MCPToolkit } from 'dynamodb-toolbox/database/actions/mcpToolkit'

// Set up your MCP Server as usual
const server = new McpServer(...)

const mcpToolkit = PokeDB.build(MCPToolkit)
mcpToolkit.addTools(server)

:::info

We highly recommend adding title and description metadata to your models for better LLM processing. For more details, see:

  • For Tables: The meta property
  • For Entities: The meta property
  • For Table Access Patterns: The meta method
  • For Entity Access Patterns: The meta method
  • For individual attributes: The schema-level meta method - its description enriches the generated tool input schemas (through the ZodSchemer), so each field is documented for the LLM

:::

Methods

addTools(...)

(server:McpServer, options?: Options) => MCPToolkit

Adds DynamoDB-Toolbox querying tools to an MCP Server. See Available Tools for a list of supported operations.

:::note[Examples]

mcpToolkit.addTools(server)

mcpToolkit.addTools(server, { readonly: true })

:::

Available tools

The following tools are available:

Access Pattern Tools

ddb-tb_use-<KEY>-access-pattern-on-<TABLE>-table

Enables querying items from the database using a registered AccessPattern.

Entity Tools

ddb-tb_get-${entityName}-item-from-${dbTableKey}-table

Enables retrieving an entity item from the database.

ddb-tb_put-${entityName}-item-in-${dbTableKey}-table

(Unavailable in readonly mode)

Enables inserting an entity item in the database.

ddb-tb_delete-${entityName}-item-from-${dbTableKey}-table

(Unavailable in readonly mode)

Enables deleting an entity item from the database.

:::info

All tools automatically apply validation, default values, links, encoding/decoding and formatting.

:::

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.