PLOMID-MCP

Connect AI clients to PLOMID through MCP.

A Rust integration layer between MCP-compatible clients and a PLOMID database: discover the tools, inspect the schema, run bounded SQL, and keep the database independent the whole way.

plomid-mcp · one governed path read-only default
01 · Client MCP client AI agent · IDE · desktop app
02 · Integration PLOMID-MCP tools · policy · bounds
STDIO HTTP
03 · Database PLOMID supported SQL protocol
8 tools · 1 prompt independent database · redacted errors
The adapter is the only database boundary. It neither bundles nor replaces PLOMID.
Status

Where PLOMID-MCP stands today.

PLOMID-MCP is implemented, tested and documented, but no tagged release has been published yet. It connects to a separately deployed PLOMID database: it does not bundle the engine, read storage files or replace the system of record. Read-only mode is the default; controlled writes follow a separate, approval-gated path.

Follow the build on GitHub

Built with
Rust, speaking the Model Context Protocol over STDIO or Streamable HTTP.
Connects to
An independently running PLOMID database over its supported SQL protocol.
Exposes
Eight tools and one prompt in the standard configuration. A ninth controlled-write tool appears only when writes are explicitly enabled.
State today
Working source tree with unit, integration and transport tests. The release workflow is configured for six native targets; no tagged release has been published yet.
Download

Take the build for your machine.

The release workflow is configured to build native packages for six targets: Linux and macOS tarballs, Windows zips. Packages appear on GitHub Releases when a version tag is pushed. Source archives and the source installer work now.

release matrix 6 native targets Release status on GitHub

Packages carry the executable, example configuration, license notices, CycloneDX SBOM and a SHA-256 checksum. They appear on the release page when a version tag is pushed. The release workflow is configured for all six targets; no tagged release has been published yet.

Source

Build the same source locally for the target above.

cargo build --release --locked --target <triple above>

Shell installer

Detects macOS or Linux and the host architecture, builds from source, and installs to ~/.local/bin. Read it before piping it to a shell.

curl -fsSL https://plomid.in/plomid-mcp-install.sh | sh
Architecture

Three trust boundaries, one request path.

The server is a protocol adapter, not a database replacement. Tools and prompts are served by the MCP process; SQL and database authorization remain at the database connection boundary.

MCP clients connect by STDIO or Streamable HTTP to PLOMID-MCP, whose tools pass through validation, authorization and SQL policy to a separately running PLOMID database.
The product's architecture drawing: consumer, integration service and database service.
  • MCP consumer The client discovers tools, chooses one and supplies arguments. It receives bounded structured content, never credentials or a raw backend error.
  • Integration service PLOMID-MCP validates arguments and applies the policy, authorization, SQL and resource checks that belong to that operation.
  • Database service PLOMID runs independently. Database roles remain the final privilege boundary even when application-level controls are configured.
Tool surface

What a client can call.

Eight tools in the standard configuration, plus one prompt that guides a client through a safe query workflow. The ninth tool, controlled SQL execution, is advertised only when the server is configured for it.

tool surface 8 tools · 1 prompt · read-only default schema v1
tools/call schema v1
Server

plomid.status

mcp:read

Reports server mode, database configuration and connectivity, with warnings.

arguments JSON
{
  "method": "tools/call",
  "params": {
    "name": "plomid.status",
    "arguments": {}
  }
}
Returns

schema_version · ok · mode · database_configured · database_status · warnings

Boundary

Reports state only. It never returns table data or connection credentials.

  • Accepts an empty argument object
  • Health check only when configured
  • Warnings are reported in place
Tool contract discover via tools/list
Request lifecycle

Every call has a bounded path.

Status and capabilities report state. Metadata tools inspect visible objects. SQL tools are parsed and bounded. The write tool has additional approval checks. Those paths do not share identical policy, on purpose.

A tool call is dispatched and validated, receives applicable policy checks, executes over PLOMID SQL, and returns bounded structured content or a stable error.
One request, tool-specific policy, bounded response — drawn from the repository.
Query defaults
100 rows and 10 seconds per request.
Tool limits
Requests clamp to 1–10,000 rows and up to 120,000 ms; process-wide caps apply after that.
Statement limits
256 KiB SQL, up to 64 parameters, each up to 64 KiB.
Result limits
Rows and encoded bytes are capped. A truncated result says so instead of silently shrinking.
Write limits
One permitted DML statement only. Administrative, transaction and multi-statement SQL are not part of the write workflow.
Security model

Read-only by default. Writes are explicit.

Parser-backed SQL policy, bounded parameters and results, redacted errors and configurable deployment controls apply to the paths they govern. Controlled writes are off until the operator turns them on.

Default SQL and resource controls, configured HTTP identity and TLS, and a separate approval-gated controlled-write path.
Defaults, deployment controls and the opt-in write path. Database grants remain the final data-access boundary.
  • One statement Read tools reject mutations, administration, transactions and data-modifying CTEs. Parameter values use protocol binding where supported.
  • Controlled writes Require controlled-write mode, an approval token digest, an idempotency key, permitted DML, the HTTP write scope where applicable, and database write grants.
  • Database is decisive Application controls do not replace PLOMID roles, TLS verification, network segmentation, secret rotation or host hardening.
Deployment

Local process or listening service.

STDIO is launched by the client; Streamable HTTP listens for local or networked clients. Either can run directly or in a container, and every path connects to an independent PLOMID database.

Local STDIO or Streamable HTTP deployment, optionally containerized, connecting to an independent PLOMID database.
Two transport paths, one database boundary. Remote HTTP requires TLS, allowed hosts and origins, and bearer identities.
Build and run
quickstart.sh shell
export PLOMID_DATABASE_URL='postgresql://USER:PASSWORD@127.0.0.1:5432/DATABASE'
cargo build --release --locked
./target/release/plomid-mcp validate
./target/release/plomid-mcp stdio

validate checks configuration; doctor checks live connectivity. STDIO protocol messages use stdout and diagnostics use stderr.

Client configuration
mcp.json json
{
  "mcpServers": {
    "plomid": {
      "command": "/absolute/path/to/plomid-mcp",
      "args": ["stdio"],
      "env": {
        "PLOMID_DATABASE_URL": "postgresql://USER:PASSWORD@127.0.0.1:5432/DATABASE"
      }
    }
  }
}

Keep the raw database URL in the client's protected environment or secret store, not in a committed file. Replace the path, URL and placeholders.

Scope

What this preview does not claim.

Application controls do not replace database roles, TLS validation, network segmentation, secret rotation or host hardening. A passing unit test does not prove the absence of vulnerabilities. Live database authentication, cancellation, external conformance, independent client compatibility and cross-platform runtime support still have to be validated in the release environment before enterprise GA.

The product's own documentation holds the exact tool contracts, configuration reference, security model and operations runbooks.

Next

Give an agent a governed way in.

Start with a read-only connection to an isolated database, discover the tools, and inspect the shapes a client can actually see. Controlled writes come later, and only when the environment is ready for them.