Skip to main content
Glama
agent-guard-mcp
by dygogogo

agent-guard-mcp

CI License: MIT Go Reference

MCP Guard Server — Budgetkontrolle, Genehmigungs-Workflows und Audit-Logging für KI-Agenten.

Funktioniert mit Claude Code, Cursor, ChatGPT und jedem KI-Agenten, der das MCP-Protokoll unterstützt.

Funktionen

  • Budgetkontrolle — Ein hartes Limit für tägliche Credits verhindert, dass Agenten zu viel ausgeben

  • Genehmigung bei hohem Risiko — Vorgänge, die einen bestimmten Betrag überschreiten oder sensible Ressourcen-Schlüsselwörter enthalten, erfordern eine menschliche Genehmigung

  • Genehmigungs-Workflow — Agentenanfrage → Token wird generiert → Mensch genehmigt über Dashboard oder Telegram

  • Audit-Log — Alle Ausgaben, Genehmigungen und Ablehnungen werden mit cursorbasierter Paginierung aufgezeichnet

  • Web-Dashboard — Echtzeit-Dashboard mit Gin + HTMX + Tailwind

  • Telegram-Benachrichtigungen — Sofortige Genehmigungslinks für risikoreiche Vorgänge

  • Multi-Transport — stdio / SSE / StreamableHTTP mit automatischer Erkennung

Related MCP server: llm-cost-guard

MCP-Tools

Tool

Beschreibung

check_budget

Abfrage des heutigen Budgetstatus

spend

Ausführung einer Ausgabe (erkennt automatisch hohes Risiko)

request_approval

Explizite Anforderung einer menschlichen Genehmigung

approve

Genehmigung eines ausstehenden Tokens

reject

Ablehnung eines ausstehenden Tokens

check_approval

Abfrage des Genehmigungsstatus

get_audit_log

Abfrage des Audit-Logs mit Filtern und Paginierung

get_pending_approvals

Auflistung aller ausstehenden Genehmigungsanfragen

Schnellstart

Voraussetzungen

  • Go 1.24+

  • Kein CGO erforderlich (reiner Go SQLite-Treiber)

Aus dem Quellcode bauen

git clone https://github.com/dygogogo/agent-guard-mcp.git
cd agent-guard-mcp
go build -o mcp-guard main.go

Vorkompiliertes Binary herunterladen

Laden Sie das neueste Release für Ihre Plattform herunter:

Oder besuchen Sie die Seite latest release.

Konfiguration

Konfiguration über Umgebungsvariablen oder eine .env-Datei:

Variable

Beschreibung

Standard

MCP_TRANSPORT

Transport: stdio / sse / http

Auto-Erkennung (TTY → http)

BUDGET_LIMIT

Tägliches Budgetlimit (Credits)

10.0

HIGH_RISK_THRESHOLD

Schwellenwert für hohes Risiko

2.0

HIGH_RISK_RESOURCES

Schlüsselwörter für risikoreiche Ressourcen (kommagetrennt)

delete,send

DB_PATH

Pfad zur SQLite-Datenbank

./mcp-guard.db

DASHBOARD_PORT

HTTP-Port des Dashboards

8080

APPROVAL_BASE_URL

Basis-URL für Genehmigungslinks

http://localhost:8080

LOG_LEVEL

Log-Level: debug/info/warn/error

info

PAYER_ID

Zahler-Identität

hostname

TELEGRAM_BOT_TOKEN

Telegram Bot Token (optional)

-

TELEGRAM_CHAT_ID

Telegram Chat ID (optional)

-

Ausführung

# HTTP mode (auto-detected, with Dashboard)
./mcp-guard
# Dashboard: http://localhost:8080/dashboard
# MCP endpoint: http://localhost:8080/mcp

# stdio mode (for MCP clients)
MCP_TRANSPORT=stdio ./mcp-guard

# SSE mode
MCP_TRANSPORT=sse ./mcp-guard
# SSE endpoint: http://localhost:8080/sse

Claude Code Integration

Zur MCP-Konfiguration von Claude Code hinzufügen:

{
  "mcpServers": {
    "agent-guard-mcp": {
      "command": "mcp-guard",
      "env": {
        "MCP_TRANSPORT": "stdio",
        "BUDGET_LIMIT": "10"
      }
    }
  }
}

Architektur

┌─────────────┐     MCP Protocol     ┌────────────────┐
│  AI Agent   │ ◄──────────────────► │  MCP Guard      │
│ (Claude,    │   stdio / HTTP       │  Server         │
│  Cursor...) │                      │                  │
└─────────────┘                      │  ┌────────────┐ │
                                     │  │  BudgetStore │ │
┌─────────────┐    HTTP              │  │  (SQLite)    │ │
│  Dashboard  │ ◄──────────────────► │  └────────────┘ │
│  (Gin+HTMX) │                      └────────────────┘
└─────────────┘

┌─────────────┐    Webhook
│  Telegram   │ ◄────── Approval notifications
└─────────────┘

Kern-Dateien

Datei

Beschreibung

main.go

Einstiegspunkt, Transportauswahl, geordnetes Herunterfahren

server.go

MCP-Server mit 8 registrierten Tools

store.go

BudgetStore-Interface + SQLite-Implementierung

approval.go

Erkennung von hohem Risiko, Genehmigungs-Workflow, Telegram

config.go

Umgebungskonfiguration, automatische Transport-Erkennung

logger.go

zap-Logging (stdio-Modus: nur Datei)

dashboard.go

Gin Web-Dashboard

Genehmigungs-Workflow

1. Agent calls spend(amount=5.0, resource="/api/delete")
2. MCP Guard detects high-risk (amount > threshold OR resource keyword matched)
3. Returns {status: "pending_approval", token: "xxx"}
4. Agent polls check_approval(token) for status
5. Human approves/rejects via Dashboard or Telegram
6. Agent receives final result (approved/rejected/budget_exceeded)

Testen

# All tests with race detection
go test -race -count=1 ./...

# Integration tests only
go test -race -run TestIntegration -v ./...

# Coverage
go test -race -cover ./...

Tech-Stack

  • Go 1.24 — Sprache

  • mcp-go — MCP-Protokoll Go SDK

  • Gin — Web-Framework (Dashboard)

  • modernc.org/sqlite — Reines Go SQLite (kein CGO)

  • zap — Strukturiertes Logging

  • HTMX + Tailwind CSS — Dashboard-Frontend

Lizenz

MIT


中文

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for AI agent security guardrails. Provides input validation, prompt injection detection, PII redaction, output filtering, policy enforcement, rate limiting, and comprehensive audit logging.
      72 npm
      1
      MIT
    • A
      license
      B
      quality
      A
      maintenance
      Governance runtime for AI agents: a guard tool evaluates risky actions against policy before they execute (block / warn / require human approval), approvals route to a human queue, and every action becomes a replayable decision record with per-action spend tracking. Runs over stdio via npx @dashclaw/mcp-server; works with Claude Code, Codex, LangChain, CrewAI, or any MCP host.
      68
      318
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      MartinLoop is the independent governance and financial control layer for AI coding agents. Set hard spend limits, prevent runaway loops, enforce verification, trigger rollback on failure, and generate auditable receipts showing what changed, what it cost, and whether the work passed.
      24
      229 npm
      286
      Apache 2.0

    Appeared in Searches