Credentials Vault MCP Server

Scoped, auditable credential access for ADK-Rust Enterprise agents. Provides 8 MCP tools over 5 pluggable vault backends — never exposes raw secrets to LLM context.

Architecture

Key Principles

• Zero secret exposure — raw secrets never reach LLM context. Tools return handles and short-lived tokens only.
• Scoped access — credentials declare which agents, skills, and MCP servers can use them.
• Full audit trail — every access, denial, rotation, and revocation is logged.
• Pluggable backends — use one or many vault backends simultaneously.
• Registry-ready — ships with mcp-server.toml for automatic ADK-Rust Enterprise onboarding.

Tools

Backends

Installation

Build from source

git clone https://github.com/zavora-ai/mcp-credentials-vault
cd mcp-credentials-vault
cargo build --release --features all-backends

The binary is at target/release/mcp-credentials-vault.

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "credentials-vault": {
      "command": "/path/to/mcp-credentials-vault",
      "args": [],
      "env": {
        "RUST_LOG": "info"
      }
    }
  }
}

Kiro

Add to your project's .kiro/settings/mcp.json:

{
  "mcpServers": {
    "credentials-vault": {
      "command": "/path/to/mcp-credentials-vault",
      "args": [],
      "env": {
        "RUST_LOG": "info"
      }
    }
  }
}

Codex (OpenAI)

Add to ~/.codex/config.json:

{
  "mcpServers": {
    "credentials-vault": {
      "command": "/path/to/mcp-credentials-vault"
    }
  }
}

Antigravity

Add to your Antigravity workspace MCP configuration:

{
  "servers": [
    {
      "name": "credentials-vault",
      "transport": "stdio",
      "command": "/path/to/mcp-credentials-vault",
      "env": {
        "RUST_LOG": "info"
      }
    }
  ]
}

Open Code

Add to ~/.config/opencode/config.json:

{
  "mcp": {
    "credentials-vault": {
      "command": "/path/to/mcp-credentials-vault",
      "args": []
    }
  }
}

Cursor

Add to .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "credentials-vault": {
      "command": "/path/to/mcp-credentials-vault",
      "args": []
    }
  }
}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "credentials-vault": {
      "command": "/path/to/mcp-credentials-vault",
      "args": []
    }
  }
}

Any MCP Client (Streamable HTTP)

For clients that support HTTP transport, run the server in HTTP mode:

mcp-credentials-vault --transport http --port 8080

Then connect your client to http://localhost:8080/mcp.

Docker

docker run -p 8080:8080 \
  -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID \
  -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY \
  -e GOOGLE_APPLICATION_CREDENTIALS=/creds/gcp.json \
  -v ~/.config/gcloud/application_default_credentials.json:/creds/gcp.json \
  ghcr.io/zavora-ai/mcp-credentials-vault:latest

Quick Start

Installation

[dependencies]
mcp-credentials-vault = { version = "1.0", features = ["all-backends"] }

Or select specific backends:

[dependencies]
mcp-credentials-vault = { version = "1.0", features = ["aws", "gcp"] }

Running as MCP Server

use mcp_credentials_vault::{adk_vault::AdkVaultBackend, server::CredentialsVaultServer};
use rmcp::{ServiceExt, transport::stdio};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let backend = AdkVaultBackend::new(Some("./credentials.json".into()));
    let server = CredentialsVaultServer::new(vec![Box::new(backend)]);
    let service = server.serve(stdio()).await?;
    service.waiting().await?;
    Ok(())
}

Multi-backend Configuration

use mcp_credentials_vault::{
    adk_vault::AdkVaultBackend,
    aws::AwsBackend,
    gcp::GcpBackend,
    server::CredentialsVaultServer,
};

let server = CredentialsVaultServer::new(vec![
    Box::new(AdkVaultBackend::new(None)),
    Box::new(AwsBackend::new(Some("us-east-1".into())).await),
    Box::new(GcpBackend::new("my-project".into()).await?),
]);

Configuration

Environment Variables

MCP Server Manifest

The server ships with mcp-server.toml for ADK-Rust Enterprise registry onboarding:

server_id = "mcp_credentials_vault"
display_name = "Credentials Vault MCP"
version = "1.0.0"
domain = "platform"
risk_level = "critical"
writes_allowed = "gated"
transports = ["stdio", "streamable_http"]
governance_gates = ["policy_evaluation_required", "audit_all_access"]

Security Model

Agent requests credential → Scope validation → Policy check → Handle issued
                                                                    │
                                                                    ▼
                                                    Runtime worker resolves
                                                    handle to actual secret
                                                    (outside LLM context)

1. Agents never see raw secrets — only handles with expiry and scope
2. Scope enforcement — credentials declare allowed actors
3. Audit everything — access, denials, rotations, revocations
4. Short-lived tokens — workload tokens expire (default 5 min for runtime, 1 hour for workload)
5. Governance gates — rotate and revoke require approval in production

Testing

# Build with all backends
cargo build --features all-backends

# Run tests (ADK Vault — no external deps)
cargo test

# Run with real backends (requires credentials)
cargo test --features all-backends

# Run the integration test binary
cargo run --features all-backends

Documentation

Contributing

See CONTRIBUTING.md for development setup and guidelines.

Contributors

License

Apache-2.0 — see LICENSE for details.

Part of the ADK-Rust Enterprise MCP server ecosystem.

Built with ❤️ by Zavora AI