How to Use the HashiCorp Vault MCP in Pydantic AI

Q: Can I use Pydantic AI to manage HashiCorp Vault ACL policies safely?

Yes, you can write agents that use createaclpolicy or listaclpolicies. The framework's type validation ensures that policy payloads conform strictly to Vault's expected JSON or HCL schemas before submission.

Q: How does Pydantic AI handle Vault token authentication?

Your agent can authenticate using userpasslogin or approlelogin to obtain a token. The framework validates the login response, allowing your agent to manage its session using lookupselftoken and renewselftoken.

Bring type-safe secret management to your Pydantic AI agents with our hosted HashiCorp Vault MCP server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect HashiCorp Vault MCP to Pydantic AI

Create your Vinkius account to connect HashiCorp Vault to Pydantic AI and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup HashiCorp Vault with Pydantic AI

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Type-Safe Secret Retrieval and Parsing

Hallucinated dictionary keys will break your production pipelines. When your agent calls `read_kv_secret`, Pydantic AI validates the returned secret payload against your strict Python schemas at runtime. If Vault returns unexpected fields or missing data, the agent fails loudly instead of passing corrupted variables downstream. This strict validation applies to metadata operations too. Running `read_kv_metadata` lets your agent check secret lifetimes and versions with absolute type certainty. You define the expected structure, and the framework guarantees the agent only processes clean, validated data.

Secure Pydantic AI Workflows with Dynamic Credentials

Hardcoded database credentials are a massive security risk. This MCP server lets your agent generate ephemeral database access tokens on demand using `generate_database_creds` or `generate_aws_creds`. Pydantic AI ensures the generated credential model matches your application's database connection schema perfectly. If the database connection drops or a lease expires, your agent can catch the validation error immediately. The agent can then invoke `renew_lease` to extend the credential lifetime or request a fresh set of keys without crashing your main application thread.

Cryptographic Operations with Strict Schema Enforcement

Performing cryptography in code is notoriously easy to mess up. Offload that risk by letting your agent encrypt and decrypt data using `encrypt_transit` and `decrypt_transit`. The transit engine handles the heavy lifting, and Pydantic AI guarantees the input and output strings conform to your exact data models. You can manage the underlying encryption keys using `create_transit_key` and `rotate_transit_key` directly through the agent. Because the keys never leave Vault, your raw cryptographic material is never exposed to the agent's execution environment.

Setup guide

Set up HashiCorp Vault MCP in Pydantic AI

Prerequisites

Python 3.10+ installed
pydantic-ai-slim[fastmcp] package
Active Vinkius subscription with a valid endpoint token

1

Install Pydantic AI with FastMCP
Run pip install "pydantic-ai-slim[fastmcp]". The FastMCP toolset replaces the deprecated MCPServerHTTP class with full protocol support.
2

Configure the FastMCPToolset
Pass a JSON-style config dict to FastMCPToolset with your Vinkius URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. Supports Streamable HTTP, SSE, and Stdio transports.
3

Create and run your agent
Pass the toolset to Agent(toolsets=[toolset]) and call agent.run(). Swap openai:gpt-4o for any supported model — Anthropic, Google, Mistral, or Groq.

agent.py

from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

toolset = FastMCPToolset({
    "mcpServers": {
        "hashicorp-vault-mcp": {
            "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
        }
    }
})

agent = Agent(
    "openai:gpt-4o",
    toolsets=[toolset],
    system_prompt="You have access to HashiCorp Vault tools.",
)

result = await agent.run("List recent HashiCorp Vault transactions")
print(result.output)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by HashiCorp Vault. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect HashiCorp Vault now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about HashiCorp Vault MCP in Pydantic AI

Install the slim package with MCP support, then initialize the MCPToolset with your Vinkius server URL. Pass this toolset into the Agent constructor to expose tools like `read_kv_secret` to your agent.

Pydantic AI will raise a validation error immediately at runtime. This prevents your agent from using malformed secrets or missing fields when calling tools like `generate_database_creds` or `read_kv_secret`.

Yes, you can write agents that use `create_acl_policy` or `list_acl_policies`. The framework's type validation ensures that policy payloads conform strictly to Vault's expected JSON or HCL schemas before submission.

Your agent can authenticate using `userpass_login` or `approle_login` to obtain a token. The framework validates the login response, allowing your agent to manage its session using `lookup_self_token` and `renew_self_token`.

Vinkius runs the server in an ephemeral, zero-trust V8 Isolate sandbox that never stores or logs your transit keys, database credentials, or API tokens. All operations are processed in memory and transmitted securely over TLS, keeping your cryptographic keys private.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript