Prototyp · Vorschau: alle Server aus der offiziellen Registry, alle 30 Minuten synchronisiert. Mit Google anmelden, um Bewertungen zu schreiben.Prototyp · alle 30 Min. aktualisiert
PopNx MCPMCP-Server für alle, die KI nutzen · in einfachen Worten erklärt

SPARDA

von zakariagharzouliVersion 0.71.4i★ 9iLäuft auf deinem ComputerRepository ↗
Name in der Registryio.github.zakariagharzouli/sparda-mcp

So installierst du es

What it does

AI writes. SPARDA proves. Deterministic, offline security gate for AI edits.

  • Connects Läuft auf deinem Computer
  • Account or key No key needed
  • Category Cybersicherheit

Warum es hier steht

Listen sind nach einem Nutzungswert (von 100) aus diesen Teilen sortiert

Beliebtheit12/80GitHub-Sterne oder wöchentliche Downloads: der größere Wert zählt 60, der kleinere 20
Aktualität7/12Volle Punkte für Release oder Codeänderung in 30 Tagen
Antwortet noch0/8Der Cloud-Endpoint antwortete bei der letzten Prüfung
Nutzungswert19/100

Qualität: 2/3 Basisprüfungen bestanden (angezeigt, nicht zur Sortierung) · Schwung: Noch keine Daten (Nur im Tab Im Trend verwendet)

Installation

Wähle die KI-App, die du nutzt, und kopiere die Einstellungen.

Mit einem Satz von deiner KI installieren lassen

Installiere bitte SPARDA. Folge https://mcp.popnx.com/i/zakariagharzouli-sparda-mcp.md, zeig mir die Befehle und warte auf mein OK, bevor du sie ausführst.

Füge ihn in eine KI ein, die auf deinem Rechner arbeitet (z. B. Claude Code oder Cursor). Sie liest unsere Schritte, zeigt dir die Befehle und wartet auf dein OK. Kein Schlüssel, keine Anmeldung. · Vollständigen Text ansehen

2/3 Prüfungen bestanden · Läuft auf deinem Computer · ✓ Befehle geprüft am 14. Nov. 2026

Zuerst: Welche KI nutzt du?

Wähle deine App, dann erscheinen die Schritte unten.

Klappt mit Claude, aber erst etwas vorbereiten

Installiere zuerst Node.js auf deinem Computer (nur einmal) · Nur in der Claude-App für den Computer (Windows oder Mac), nicht im Web oder auf dem Handy

Von der KI installieren lassen

Kopiere diese Nachricht in einen Claude-Chat. Die KI prüft deinen Rechner, sagt dir, welche Datei sie ändert, und wartet jedes Mal auf dein OK.

Installiere bitte den MCP server SPARDA für Claude auf diesem Rechner, in dieser Reihenfolge: 1) Prüfe Node.js mit node -v. Fehlt es, sag mir, dass ich es von https://nodejs.org/en/download installiere; installiere es nicht selbst. 2) Verwende nur diese Konfiguration (von PopNx MCP geprüft): { "mcpServers": { "sparda": { "command": "npx", "args": [ "-y", "sparda-mcp", "dev" ] } } } 3) Nenne mir den vollständigen Pfad der Datei, die du änderst, oder den Befehl, den du ausführst, und warte auf mein OK. 4) Kein Schlüssel nötig. 5) Führe das Vereinbarte aus und prüfe, dass die Tools von SPARDA wirklich erscheinen.

Diese Nachricht enthält keinen Schlüssel. Wird einer gebraucht, bittet dich die KI, ihn selbst in die Datei oder das Feld der App einzufügen.

  1. Node.js installieren (falls noch nicht vorhanden)

    Schon installiert? Zuerst prüfen · Öffne das Terminal, gib diesen Befehl ein und drücke Enter

    node -v
    • Eine Versionsnummer wie v26.13.1 = installiert, diesen Schritt überspringen
    • "command not found" (unter Windows "is not recognized") = noch nicht installiert, oder gerade installiert und das Terminal muss neu geöffnet werden
    So öffnest du das Terminal

    Mac: ⌘ + Leertaste drücken, Terminal eingeben, Enter

    Windows: Start öffnen, Windows PowerShell eingeben, dann Öffnen

    Noch nicht installiert: Öffne die offizielle Download-Seite, wähle die LTS-Version und den Klick-Installer: .pkg auf dem Mac · .msi unter Windows. Doppelklicken und bis zum Ende durchklicken. Kein curl-Befehl nötig

    Download-Seite von Node.js öffnen ↗

    Danach das Terminal schließen, neu öffnen und denselben Befehl erneut ausführen. Es muss eine Versionsnummer erscheinen: node -v

    Einmal installieren, gilt für alles, was Node.js braucht

  2. Einstellungsdatei der Claude-Desktop-App öffnen

    SettingsDeveloperEdit Config

  3. Diese Einstellungen einfügen und speichern

    {
      "mcpServers": {
        "sparda": {
          "command": "npx",
          "args": [
            "-y",
            "sparda-mcp",
            "dev"
          ]
        }
      }
    }
  4. Claude beenden und neu öffnen

  5. Ausprobieren

    Nutze SPARDA und sag mir, was du für mich tun kannst; zeig mir dann eine Sache

    ✓ Wenn Claude sagt, dass es SPARDA nutzt, oder ein Werkzeug von SPARDA in der Antwort zeigt, bist du verbunden

2 optionale Einstellung(en) (geht auch ohne)

Der Befehl oben funktioniert auch ohne diese Werte. Füge sie nur hinzu, wenn du etwas ändern willst, nach der Beschreibung des Autors.

  • SPARDA_FLYWHEEL Auf off setzen, um die Ausgabe bewährt stabiler Lesevorgänge aus dem Speicher zu deaktivieren (Organs lernen weiterhin).
    Englisches Original anzeigenSet to `off` to disable serving proven-stable reads from memory (organs keep learning).
  • SPARDA_RECORD_SEQUENCES Auf 1 setzen, um die Circuit-Aufzeichnung von Labs zu aktivieren (wiederholte Werkzeugketten werden zu zusammengesetzten Werkzeugen kristallisiert).
    Englisches Original anzeigenSet to `1` to enable Labs circuit recording (crystallizes repeated tool chains into composite tools).

Beschreibungen automatisch übersetzt; Variablennamen bleiben wie im Original. Im Zweifel das Original ansehen.

Menünamen am 11. Nov. 2026 mit der Hilfe von Anthropic abgeglichen · dein Bildschirm kann je nach App-Version leicht abweichen

ChatGPT kann SPARDA noch nicht verbinden

SPARDA läuft auf deinem Computer, aber ChatGPT verbindet nur Server, die im Web laufen

Das kannst du stattdessen tun

A · Eine App nutzen, die SPARDA verbinden kann

  • Installiere zuerst Node.js auf deinem Computer (nur einmal) · Nur in der Claude-App für den Computer (Windows oder Mac), nicht im Web oder auf dem Handy
  • Installiere zuerst Node.js auf deinem Computer (nur einmal)
  • Installiere zuerst Node.js auf deinem Computer (nur einmal)
  • Installiere zuerst Node.js auf deinem Computer (nur einmal)

B · Andere in Cybersicherheit, die mit ChatGPT funktionieren

Aus den meistgenutzten derselben Kategorie, nur solche, die per Adresse ohne Schlüssel verbinden

Klappt mit Claude Code, aber erst etwas vorbereiten

Installiere zuerst Node.js auf deinem Computer (nur einmal)

Von der KI installieren lassen

Kopiere diese Nachricht in einen Claude Code-Chat. Die KI prüft deinen Rechner, sagt dir, welche Datei sie ändert, und wartet jedes Mal auf dein OK.

Installiere bitte den MCP server SPARDA für Claude Code auf diesem Rechner, in dieser Reihenfolge: 1) Prüfe Node.js mit node -v. Fehlt es, sag mir, dass ich es von https://nodejs.org/en/download installiere; installiere es nicht selbst. 2) Verwende nur diese Konfiguration (von PopNx MCP geprüft): claude mcp add --scope user sparda -- npx -y sparda-mcp dev 3) Nenne mir den vollständigen Pfad der Datei, die du änderst, oder den Befehl, den du ausführst, und warte auf mein OK. 4) Kein Schlüssel nötig. 5) Führe das Vereinbarte aus und prüfe, dass die Tools von SPARDA wirklich erscheinen.

Diese Nachricht enthält keinen Schlüssel. Wird einer gebraucht, bittet dich die KI, ihn selbst in die Datei oder das Feld der App einzufügen.

  1. Node.js installieren (falls noch nicht vorhanden)

    Schon installiert? Zuerst prüfen · Öffne das Terminal, gib diesen Befehl ein und drücke Enter

    node -v
    • Eine Versionsnummer wie v26.13.1 = installiert, diesen Schritt überspringen
    • "command not found" (unter Windows "is not recognized") = noch nicht installiert, oder gerade installiert und das Terminal muss neu geöffnet werden
    So öffnest du das Terminal

    Mac: ⌘ + Leertaste drücken, Terminal eingeben, Enter

    Windows: Start öffnen, Windows PowerShell eingeben, dann Öffnen

    Noch nicht installiert: Öffne die offizielle Download-Seite, wähle die LTS-Version und den Klick-Installer: .pkg auf dem Mac · .msi unter Windows. Doppelklicken und bis zum Ende durchklicken. Kein curl-Befehl nötig

    Download-Seite von Node.js öffnen ↗

    Danach das Terminal schließen, neu öffnen und denselben Befehl erneut ausführen. Es muss eine Versionsnummer erscheinen: node -v

    Einmal installieren, gilt für alles, was Node.js braucht

  2. Terminal öffnen

    Mac: Command+Leertaste drücken und Terminal tippen · Windows: PowerShell öffnen

  3. Diesen Befehl einfügen und Enter drücken

    claude mcp add --scope user sparda -- npx -y sparda-mcp dev
  4. /mcp in Claude Code eingeben

    SPARDA sollte in der Liste als verbunden erscheinen

  5. Ausprobieren

    Nutze SPARDA und sag mir, was du für mich tun kannst; zeig mir dann eine Sache

    ✓ Wenn Claude Code sagt, dass es SPARDA nutzt, oder ein Werkzeug von SPARDA in der Antwort zeigt, bist du verbunden

2 optionale Einstellung(en) (geht auch ohne)

Der Befehl oben funktioniert auch ohne diese Werte. Füge sie nur hinzu, wenn du etwas ändern willst, nach der Beschreibung des Autors.

  • SPARDA_FLYWHEEL Auf off setzen, um die Ausgabe bewährt stabiler Lesevorgänge aus dem Speicher zu deaktivieren (Organs lernen weiterhin).
    Englisches Original anzeigenSet to `off` to disable serving proven-stable reads from memory (organs keep learning).
  • SPARDA_RECORD_SEQUENCES Auf 1 setzen, um die Circuit-Aufzeichnung von Labs zu aktivieren (wiederholte Werkzeugketten werden zu zusammengesetzten Werkzeugen kristallisiert).
    Englisches Original anzeigenSet to `1` to enable Labs circuit recording (crystallizes repeated tool chains into composite tools).

Beschreibungen automatisch übersetzt; Variablennamen bleiben wie im Original. Im Zweifel das Original ansehen.

Menünamen am 11. Nov. 2026 mit der Hilfe von Anthropic abgeglichen · dein Bildschirm kann je nach App-Version leicht abweichen

Klappt mit Cursor, aber erst etwas vorbereiten

Installiere zuerst Node.js auf deinem Computer (nur einmal)

Von der KI installieren lassen

Kopiere diese Nachricht in einen Cursor-Chat. Die KI prüft deinen Rechner, sagt dir, welche Datei sie ändert, und wartet jedes Mal auf dein OK.

Installiere bitte den MCP server SPARDA für Cursor auf diesem Rechner, in dieser Reihenfolge: 1) Prüfe Node.js mit node -v. Fehlt es, sag mir, dass ich es von https://nodejs.org/en/download installiere; installiere es nicht selbst. 2) Verwende nur diese Konfiguration (von PopNx MCP geprüft): { "mcpServers": { "sparda": { "command": "npx", "args": [ "-y", "sparda-mcp", "dev" ] } } } 3) Nenne mir den vollständigen Pfad der Datei, die du änderst, oder den Befehl, den du ausführst, und warte auf mein OK. 4) Kein Schlüssel nötig. 5) Führe das Vereinbarte aus und prüfe, dass die Tools von SPARDA wirklich erscheinen.

Diese Nachricht enthält keinen Schlüssel. Wird einer gebraucht, bittet dich die KI, ihn selbst in die Datei oder das Feld der App einzufügen.

  1. Node.js installieren (falls noch nicht vorhanden)

    Schon installiert? Zuerst prüfen · Öffne das Terminal, gib diesen Befehl ein und drücke Enter

    node -v
    • Eine Versionsnummer wie v26.13.1 = installiert, diesen Schritt überspringen
    • "command not found" (unter Windows "is not recognized") = noch nicht installiert, oder gerade installiert und das Terminal muss neu geöffnet werden
    So öffnest du das Terminal

    Mac: ⌘ + Leertaste drücken, Terminal eingeben, Enter

    Windows: Start öffnen, Windows PowerShell eingeben, dann Öffnen

    Noch nicht installiert: Öffne die offizielle Download-Seite, wähle die LTS-Version und den Klick-Installer: .pkg auf dem Mac · .msi unter Windows. Doppelklicken und bis zum Ende durchklicken. Kein curl-Befehl nötig

    Download-Seite von Node.js öffnen ↗

    Danach das Terminal schließen, neu öffnen und denselben Befehl erneut ausführen. Es muss eine Versionsnummer erscheinen: node -v

    Einmal installieren, gilt für alles, was Node.js braucht

  2. Mit diesem Button Cursor öffnen

    In Cursor öffnen

    Cursor fragt nach einer Bestätigung; klicke Install

  3. KI-Chat in Cursor im Agent-Modus öffnen

  4. Ausprobieren

    Nutze SPARDA und sag mir, was du für mich tun kannst; zeig mir dann eine Sache

    ✓ Wenn Cursor sagt, dass es SPARDA nutzt, oder ein Werkzeug von SPARDA in der Antwort zeigt, bist du verbunden

2 optionale Einstellung(en) (geht auch ohne)

Der Befehl oben funktioniert auch ohne diese Werte. Füge sie nur hinzu, wenn du etwas ändern willst, nach der Beschreibung des Autors.

  • SPARDA_FLYWHEEL Auf off setzen, um die Ausgabe bewährt stabiler Lesevorgänge aus dem Speicher zu deaktivieren (Organs lernen weiterhin).
    Englisches Original anzeigenSet to `off` to disable serving proven-stable reads from memory (organs keep learning).
  • SPARDA_RECORD_SEQUENCES Auf 1 setzen, um die Circuit-Aufzeichnung von Labs zu aktivieren (wiederholte Werkzeugketten werden zu zusammengesetzten Werkzeugen kristallisiert).
    Englisches Original anzeigenSet to `1` to enable Labs circuit recording (crystallizes repeated tool chains into composite tools).

Beschreibungen automatisch übersetzt; Variablennamen bleiben wie im Original. Im Zweifel das Original ansehen.

Menünamen am 11. Nov. 2026 mit der Hilfe von Cursor abgeglichen · dein Bildschirm kann je nach App-Version leicht abweichen

Klappt mit VS Code, aber erst etwas vorbereiten

Installiere zuerst Node.js auf deinem Computer (nur einmal)

Von der KI installieren lassen

Kopiere diese Nachricht in einen VS Code-Chat. Die KI prüft deinen Rechner, sagt dir, welche Datei sie ändert, und wartet jedes Mal auf dein OK.

Installiere bitte den MCP server SPARDA für VS Code auf diesem Rechner, in dieser Reihenfolge: 1) Prüfe Node.js mit node -v. Fehlt es, sag mir, dass ich es von https://nodejs.org/en/download installiere; installiere es nicht selbst. 2) Verwende nur diese Konfiguration (von PopNx MCP geprüft): { "servers": { "sparda": { "type": "stdio", "command": "npx", "args": [ "-y", "sparda-mcp", "dev" ] } } } 3) Nenne mir den vollständigen Pfad der Datei, die du änderst, oder den Befehl, den du ausführst, und warte auf mein OK. 4) Kein Schlüssel nötig. 5) Führe das Vereinbarte aus und prüfe, dass die Tools von SPARDA wirklich erscheinen.

Diese Nachricht enthält keinen Schlüssel. Wird einer gebraucht, bittet dich die KI, ihn selbst in die Datei oder das Feld der App einzufügen.

  1. Node.js installieren (falls noch nicht vorhanden)

    Schon installiert? Zuerst prüfen · Öffne das Terminal, gib diesen Befehl ein und drücke Enter

    node -v
    • Eine Versionsnummer wie v26.13.1 = installiert, diesen Schritt überspringen
    • "command not found" (unter Windows "is not recognized") = noch nicht installiert, oder gerade installiert und das Terminal muss neu geöffnet werden
    So öffnest du das Terminal

    Mac: ⌘ + Leertaste drücken, Terminal eingeben, Enter

    Windows: Start öffnen, Windows PowerShell eingeben, dann Öffnen

    Noch nicht installiert: Öffne die offizielle Download-Seite, wähle die LTS-Version und den Klick-Installer: .pkg auf dem Mac · .msi unter Windows. Doppelklicken und bis zum Ende durchklicken. Kein curl-Befehl nötig

    Download-Seite von Node.js öffnen ↗

    Danach das Terminal schließen, neu öffnen und denselben Befehl erneut ausführen. Es muss eine Versionsnummer erscheinen: node -v

    Einmal installieren, gilt für alles, was Node.js braucht

  2. Mit diesem Button VS Code öffnen

    In VS Code öffnen

    VS Code fragt nach einer Bestätigung; klicke Install

  3. KI-Chat in VS Code im Agent-Modus öffnen

  4. Ausprobieren

    Nutze SPARDA und sag mir, was du für mich tun kannst; zeig mir dann eine Sache

    ✓ Wenn VS Code sagt, dass es SPARDA nutzt, oder ein Werkzeug von SPARDA in der Antwort zeigt, bist du verbunden

2 optionale Einstellung(en) (geht auch ohne)

Der Befehl oben funktioniert auch ohne diese Werte. Füge sie nur hinzu, wenn du etwas ändern willst, nach der Beschreibung des Autors.

  • SPARDA_FLYWHEEL Auf off setzen, um die Ausgabe bewährt stabiler Lesevorgänge aus dem Speicher zu deaktivieren (Organs lernen weiterhin).
    Englisches Original anzeigenSet to `off` to disable serving proven-stable reads from memory (organs keep learning).
  • SPARDA_RECORD_SEQUENCES Auf 1 setzen, um die Circuit-Aufzeichnung von Labs zu aktivieren (wiederholte Werkzeugketten werden zu zusammengesetzten Werkzeugen kristallisiert).
    Englisches Original anzeigenSet to `1` to enable Labs circuit recording (crystallizes repeated tool chains into composite tools).

Beschreibungen automatisch übersetzt; Variablennamen bleiben wie im Original. Im Zweifel das Original ansehen.

Menünamen am 11. Nov. 2026 mit der Hilfe von VS Code abgeglichen · dein Bildschirm kann je nach App-Version leicht abweichen

Andere Apps mit MCP, etwa Windsurf, Zed oder Gemini CLI, fügen Server unterschiedlich hinzu. Sieh in der App-Liste nach

Alle Apps mit MCP ansehen →

JSON-Einstellungen stehen unten unter „Für Entwickler“

Hängst du fest? Frag Leute, die SPARDA nutzen💬 Diskussion →
Für Entwickler: Terminal-Befehle und JSON-Einstellungen

Auf deinem Computer installiert

Claude Code

claude mcp add --scope user sparda -- npx -y sparda-mcp dev

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "sparda": {
      "command": "npx",
      "args": [
        "-y",
        "sparda-mcp",
        "dev"
      ]
    }
  }
}

Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "sparda": {
      "command": "npx",
      "args": [
        "-y",
        "sparda-mcp",
        "dev"
      ]
    }
  }
}

VS Code (mcp.json)

{
  "servers": {
    "sparda": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "sparda-mcp",
        "dev"
      ]
    }
  }
}

Werte, die du selbst einträgst

  • SPARDA_FLYWHEEL env
    Auf off setzen, um die Ausgabe bewährt stabiler Lesevorgänge aus dem Speicher zu deaktivieren (Organs lernen weiterhin).
    Englisches Original anzeigenSet to `off` to disable serving proven-stable reads from memory (organs keep learning).
  • SPARDA_RECORD_SEQUENCES env
    Auf 1 setzen, um die Circuit-Aufzeichnung von Labs zu aktivieren (wiederholte Werkzeugketten werden zu zusammengesetzten Werkzeugen kristallisiert).
    Englisches Original anzeigenSet to `1` to enable Labs circuit recording (crystallizes repeated tool chains into composite tools).

Beschreibungen automatisch übersetzt; Variablennamen bleiben wie im Original. Im Zweifel das Original ansehen.

Diese Einstellungen werden aus dem Registry-Eintrag des Entwicklers erzeugt. Wenn in der README etwas anderes steht, folge der README.

Auf einen Blick

Downloads pro Wochei
272/Wo.
Lizenzi
Keine Lizenz angegeben
Verbindung
Läuft auf deinem Computer
Neueste Versioni
0.71.4
In der Registry veröffentlichti
2. Sept. 2026
Code zuletzt geänderti
16. Sept. 2026
Entwickler
zakariagharzouli
Pakete
npm: sparda-mcp
Registry-Status
Aktiv

Welche Apps ihn nutzen können

Basierend darauf, wie sich dieser Server verbindet, und auf der eigenen Doku jeder App, geprüft am 10. Nov. 2026.

Laufen auf deinem Computer in

ClaudeGooseLM StudioMsty StudioCherry StudioCursorVS Code + GitHub CopilotVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantClaude CodeCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatRaycast

Alle Apps, mit Vor- und Nachteilen →

Was er kann

Läuft auf deinem Computer; die Tool-Liste erscheint nach der Installation in deiner KI-App.

Basischecksi

Wir prüfen Informationen, die jeder sehen kann; den Code haben wir nicht gelesen. Checks, die nicht zutreffen, werden nicht mitgezählt. · Geprüft am 20. Nov. 2026

  • ✓ Bestanden

    Entwickler passt zum Repo

    Der Registry-Name wurde mit dem GitHub-Konto zakariagharzouli bestätigt, dem das Repo gehört

  • ✓ Bestanden

    Wird noch gepflegt

    Code zuletzt geändert: vor 2 Monaten

  • ! Vorsicht

    Hat eine Lizenz

    GitHub konnte die Lizenzart nicht erkennen; öffne die Datei, um nachzusehen

  • – Nicht zutreffend

    Endpunkt antwortet

    Dieser Server läuft auf deinem Computer; es gibt keinen Endpunkt im Internet

  • – Nicht zutreffend

    Anmeldung mit OAuth

    Läuft auf deinem Computer und nutzt stattdessen lokale Einstellungen

  • … Noch nicht geprüft

    Keine versteckten Anweisungen in Tool-Beschreibungen

    Läuft auf deinem Computer; Tool-Listen können wir nur von Endpunkten im Internet lesen

Veröffentlichte Schwachstellen (OSV.dev)

Keine Einträge auf OSV.dev für sparda-mcp@0.71.4

Prüft nur diese Paketversion, nicht alle Abhängigkeiten · geprüft 15. Nov. 2026

Was wir prüfen → · JSON

Entwickler: neue Prüfung anfordern oder falsche Angaben melden
Für Anbieter: Badge ins README

Wenn du das gebaut hast, füge diesen Code in dein README ein. Das Badge verlinkt auf diese Seite.

[![Featured on PopNx MCP](https://mcp.popnx.com/badge/zakariagharzouli-sparda-mcp.svg)](https://mcp.popnx.com/en/servers/zakariagharzouli-sparda-mcp)

Diskussion

Fragen, Tipps teilen oder melden, dass etwas nicht geht. Sortiert nach „hilfreich“.

Noch keine Beiträge. Stell die erste Frage oder teile einen Tipp.

Beiträge hier stammen von Nutzern, nicht vom PopNx-Team.

Anmelden, um zu posten

Nutzerbewertungen

Noch keine Bewertungen

Anmelden, um eine Bewertung zu schreiben

Im Vergleich mit anderen in Cybersicherheiti

  • Mehr Sterne als 92 % der anderen 1120 Server in dieser Kategorie
  • Neuer in der Registry veröffentlicht als 34 % der anderen 1120 Server in dieser Kategorie
  • Basischecks gleich gut wie oder besser als bei 46 % der anderen 1120 Server in dieser Kategorie

Verglichen mit allen aktiven Servern dieser Kategorie in der Registry. Sterne zählen nur, wenn dem Herausgeber das Repo gehört.

Häufige Fragen

Ist SPARDA sicher?

Er hat 2 von 3 zutreffenden Basischecks bestanden. Den Code haben wir nicht gelesen. Bevor du einen Schlüssel oder Token hinzufügst, sieh nach, welche Zugriffe der Server verlangt, und nutze einen Schlüssel, der nur die Berechtigungen hat, die du brauchst.

Welche Schlüssel oder Codes braucht er?

Die Registry nennt keinen erforderlichen Schlüssel, manche Server bitten dich aber bei der ersten Nutzung, dich anzumelden.

Läuft er auf meinem Computer oder in der Cloud?

Er läuft auf deinem Computer. Deine KI-App startet ihn bei Bedarf, und die Daten laufen nicht über die Server des Entwicklers (außer der Server ruft selbst einen Onlinedienst auf).

Wird er noch gepflegt?

Das GitHub-Repo wurde zuletzt vor 2 Monaten geändert, und die neueste Version (0.71.4) kam vor 3 Monaten in die Registry.

Welche Apps können ihn nutzen?

Apps, die MCP unterstützen, etwa Claude Desktop, Claude Code, Cursor und VS Code. Außerdem brauchst du Node.js auf deinem Computer.

Was kann ich stattdessen nutzen?

In derselben Kategorie: GitHits, Dependency Management MCP Server, Snyk MCP, TokenSafe, Draugr

Ähnliche Alternativen

Gleiche Kategorie, andere Entwickler, Befehle bereits geprüft. Offizielle zuerst, dann nach Sternen.

So liest du eine Karte:↓ Downloads pro Wochei★ GitHub-SterneiDrei Säulen: Bewertungen · Checks · NutzungiAktualisiert = neueste Version in der Registry veröffentlichti

GitHits

Search public open-source code, documentation, metadata, vulnerabilities, changelogs, and examples.

von githits-comWachsend↓ 3807/Wo.★ 138Aktualisiert gestern

Computer oder Cloud✓ vom Dienst · githits.com

Snyk MCP

Easily find and fix security issues in your applications leveraging Snyk platform capabilities.

von snykWeit verbreitet↓ 762.141/Wo.★ 61Aktualisiert vor 7 Monaten

Läuft auf deinem Computer✓ vom Dienst · snyk.io

TokenSafe

Your AI agent is smart enough to code all day. Local firewall & zero-loss runtime.

von tokensafe-devWeit verbreitet↓ 6785/Wo.★ 47Aktualisiert gestern

Computer oder Cloud✓ vom Dienst · tokensafe.dev

Draugr

Security scanning for AI agents: SAST, SCA, secrets, IaC, DAST, ranked by real risk.

von draugr-devAm Anfang★ 30Aktualisiert vor 3 Tagen

Läuft auf deinem Computer✓ vom Dienst · draugr.dev
Im Vergleich mit ähnlichen
Dieser
SPARDA
GitHitsDependency Management MCP ServerSnyk MCPTokenSafeDraugr
Läuft woWird auf deinem Rechner installiertIn der Cloud oder auf deinem RechnerLäuft in der Cloud, keine InstallationWird auf deinem Rechner installiertIn der Cloud oder auf deinem RechnerWird auf deinem Rechner installiert
Braucht SchlüsselNeinNeinNeinNeinNeinNein
Mit + in Claude hinzufügenNeinNeinNeinNeinNeinNein
Basisprüfungen2/35/53/43/35/53/3
LizenzNOASSERTIONApache-2.0–Apache-2.0MITApache-2.0
PreisKeine Kosten im RegisterKeine Kosten im RegisterKeine Kosten im RegisterKeine Kosten im RegisterKeine Kosten im RegisterKeine Kosten im Register

README vom Entwickler

README öffnen

Unverändert aus dem Repo des Entwicklers übernommen. PopNx MCP hat den Inhalt weder geprüft noch empfiehlt es ihn. HTML, Bilder und Skripte wurden entfernt. Links führen von dieser Website weg.

SPARDA

🇫🇷 Français — _L'IA écrit. SPARDA prouve._ Un gate déterministe et hors-ligne qui détecte quand une modif d'IA retire une garde, expose une route ou casse un invariant — sans clé API, directement dans la boucle d'édition de l'agent. Pour tout comprendre en 10 minutes (douleur, architecture, vision) : SPARDA-EXPLIQUE.md.


AI writes. SPARDA proves. L'IA écrit. SPARDA prouve.

The trust layer for AI-written backends. SPARDA compiles your backend — routes, database queries, state mutations, guards, side-effects — into one deterministic behavior graph, then statically proves what can and can't break before you ship: no unguarded mutation, no broken invariant, no non-atomic aggregate write.

100% local · deterministic · zero API key · no cloud account. It fails loudly on a real risk, and when it can only see part of your app it says PROVEN (PARTIAL) — never a false green. And when it can prove it was not even looking at your whole app, it says PREMISE NOT VERIFIED and claims nothing at all.

60-second proof

From your Express, FastAPI, Flask, Next.js, NestJS or Medusa app — nothing to configure:

npx sparda-mcp apocalypse   # prove the tree is safe to deploy — exit 1 on any real risk, or on an unverified premise

npx sparda-mcp prove # the whole verdict: proof + coverage + shareable seal npx sparda-mcp badge # a README badge: proven · coverage% · routes

Under the hood it compiles your backend into one language-agnostic graph — the Unified Behavior Graph (UBG), serialized as .sparda/ubg.json under the SBIR specification (SPARDA Behavior IR) — and every command is a pass over that graph.

The wedge — catch an AI edit that removes a guard, in the loop

The one thing a text-diff review and a pattern scanner structurally can't do: prove that this specific edit dropped a protection the previous version had. sparda gate diffs the behavior graph before/after an edit and blocks a regression — deterministic, offline, sub-second, exit 2 (the Claude Code PostToolUse contract that stops the agent's edit loop). See it end-to-end in one command, zero setup:

npm run wedge     # (from a clone)  — or drive it on your own app with `sparda gate --arm` then `sparda gate --hook`
  1. baseline armed on the guarded code   (POST /admin/delete-user · requireAdmin)
  1. an AI edit "simplifies" requireAdmin → a pass-through (still compiles, still 200s)
  2. sparda gate on the edit: ✗ [critical] GUARD_REMOVED — POST /admin/delete-user was guarded in the baseline and is now reachable without any guard (src/app.js:11) ⏱ ~40 ms · deterministic · offline · no API key ⛔ exit 2 on --hook — Claude Code PostToolUse blocks the edit

Wire it into Claude Code in one line — the plugin registers a PostToolUse hook that runs npx -y sparda-mcp gate --hook after every Edit/Write, so a guard-removing edit is caught before it lands.

[!IMPORTANT]

The Route-Compilation Proof — reproduce it yourself. SPARDA compiles real open-source monsters to their behavior graph with zero crashes, each in ≈1–2 seconds: Next.js _Dub_ (579 routes), NestJS _Immich_ (281), _MedusaJS_ (477). It natively resolves deep Dependency Injection, external controllers, and Next.js handlers. One command clones them and re-measures on your machine:

`bash

node bench/repro.mjs # → bench/route-proof.json

`

Honesty first: _compiling_ a route is a parser result (the number above); _proving_ it safe is a separate per-repo verdict — and most real apps come back NOT_PROVEN, which is the true state, not a failure. (Our full 25-repo corpus stress compiles 3,565 routes at ~150 routes/s; that one needs the corpus checked out.)

What the graph unlocks — 100% local, deterministic, 4 exact-pinned dependencies, zero API key:

CommandWhat it does
`prove`_The whole trust verdict in one gesture_ — proof + coverage + premise check + a shareable seal (--json / --markdown)
`apocalypse`_Prove the deploy_ — no guard, invariant, transaction or aggregate boundary can be broken (SARIF + CI gate)
`heal`_Self-heal, proven_ — the gate Copilot Autofix doesn't have: a fix ships only if replay matches, verify still passes, and apocalypse finds no new risk / no dropped guard. Whoever wrote the fix, the machine judges it.
`badge`_The shareable artifact_ — a self-contained SVG badge + README snippet (verdict · coverage · routes)
`dossier`_The public report_ — one self-contained HTML page: verdict, risks, and SPARDA's own blind spots
`ubg`Compile the codebase to its behavior graph (Express · FastAPI · Flask · Next.js · NestJS · Medusa natively; any stack via OpenAPI)
`timeless`_Time-travel_ — record a production request, replay it byte-identically, export the bug as a test
`mirror`_Execute the graph_ — serve the compiled behavior over HTTP with no framework and no source
`init` / `dev`_Runtime, optional_ — expose the graph to AI clients as a live MCP server (+ Twin, Immune, Evolution)

The prover is the product. The MCP server is one _output_ of the graph, not the point — SPARDA compiles the whole system's behavior, then proves, replays, heals, and (optionally) serves it.

Nomenclature: SBIR is the specification (the format, like "JSON"); UBG is the compiled graph itself (the artifact, ubg.json). The MCP server is one _output_ of the graph, not the product.

Optional: expose the graph to AI clients (MCP runtime)

Beyond proving, SPARDA can turn your running app into a live MCP server — the graph, executable, with write-safety and an immune layer. This is optional and separate from the prover above.

  1. Scan + inject — run once, from your app's directory:
   npx sparda-mcp init

SPARDA parses your routes (AST), generates a marked /mcp router, injects it into your app (with a backup), and writes sparda.json. Every step is reversible.

  1. Start your app, then start the bridge:
   npx sparda-mcp dev
  1. Connect your client. init prints a ready-to-paste block for claude_desktop_config.json, pre-filled with your app's name and path:
   {

"mcpServers": { "your-app": { "command": "npx", "args": ["sparda-mcp", "dev"], "cwd": "/absolute/path/to/your-app" } } }

   Claude Code connects to the same bridge. That's it — your running app is now a set

of MCP tools your AI can call.

Try the Standalone Demo

To see SPARDA in action instantly without modifying your codebase:

npx sparda-mcp demo

This runs the entire MCP lifecycle (detect → parse → generate → inject → remove) on a bundled demo app in a temporary folder, in about 10 seconds. For the compiler itself, run npx sparda-mcp ubg then apocalypse on any Express/FastAPI app.

Black Box Report

SPARDA is designed as a local organism. To see what it remembers and how much compute it has recycled:

npx sparda-mcp report

This prints a terminal dashboard aggregating your exposed tools, write opt-ins, proof journal decisions, and crystallized composite tools.

To write a self-contained, offline HTML dashboard at .sparda/report.html, append the --html flag:

npx sparda-mcp report --html

To output raw JSON for integration:

npx sparda-mcp report --json

Deployment Proof: Apocalypse

SPARDA's Behavior Graph is a formal model of your system. Instead of waiting for runtime failures or relying on static analysis vibes, you can statically prove the safety of your backend before any deployment:

npx sparda-mcp apocalypse

This command reads the compiled .sparda/ubg.json (with zero source code parsing at runtime) and discharges five static correctness obligations:

  • Unguarded Mutation (Critical): Flags any mutation path that does not cross a security guard.
  • Non-Atomic Aggregate Write (High): Flags when an API writes to multiple tables of the same Consistency Domain (Aggregate) outside a single transaction scope.
  • Unvalidated Constrained Write (Medium): Flags writes into columns with declared invariants (CHECK, NOT NULL, UNIQUE — parsed from your .sql DDL or `schema.prisma`, Prisma enums included) without prior validation (Zod/Pydantic).
  • Irreversible Observable Effect (High): Flags out-of-process actions (like Stripe charges) that happen alongside state writes without a structural compensation path (like a catch-refund).
  • Aggregate Member Bypass (Info): Flags mutating a member table directly without routing through the aggregate root.

To save your current graph as a safe baseline:

npx sparda-mcp apocalypse --save-baseline

Subsequent runs will diff the candidate graph against this baseline to detect regression vectors:

  • Deletion of any security guard (Critical).
  • Deletion of a database SQL invariant (High).
  • API blast radius expansion (Medium).

If any Critical or High finding is found, apocalypse exits with a non-zero code to block your CI pipeline.

One step in your workflow — findings land in the GitHub Security tab (SARIF):

- uses: zakariagharzouli/sparda@main

with: sarif: 'true'

Time Travel: Timeless

Every production request is deterministic between its effects — the compiler knows exactly where the nondeterminism lives (db, http, clock, random, uuid: the effect nodes of the graph). Timeless records only those points (a few KB per request) and replays the request **byte-iden

Nur der Anfang wird gezeigt; den Rest findest du im Repo