Project Guardian MCP

Ein Model Context Protocol (MCP)-Server für persistentes Projektgedächtnis, Knowledge-Graph-Operationen, SQLite-Datenzugriff, Laufzeit-Sicherheitsprüfungen und geführte Projektmanagement-Workflows. Die aktuelle Registry stellt 34 Tools, 11 Ressourcen und 27 Prompts bereit.

Inhaltsverzeichnis

• Funktionen

  • Project-Guardian-Gedächtnissystem

  • Optimierte Datenbankoperationen

  • Integration des Laufzeit-Begleiters

  • KI-Leitsystem

  • Erweiterte Funktionen

  • Enterprise-Funktionen

• Voraussetzungen

• Installation

• Verfügbare Tools

  • Datenbankoperationen (7 Tools)

  • Gedächtnis- und Leittools (11 Tools)

  • Laufzeit-Begleiter-Tools (12 Tools)

  • UI-Tools (4 Tools)

• KI-Leitsystem

  • Verfügbare Ressourcen

  • Verfügbare Prompts

  • Wie KI-Modelle die Leitlinien nutzen

• Anwendungsbeispiele

  • Project-Guardian-Einrichtung

  • Projektmanagement-Workflow

  • Datenbankoperationen

• Konfiguration

  • Optionale Laufzeitdienste

  • Für Cursor IDE

  • Für Claude Desktop

• Projektstruktur

• Entwicklung

• Lizenz

Related MCP server: Engram

Funktionen

Project-Guardian-Gedächtnissystem

• Knowledge Graph: Verwaltet Projektentitäten, Beziehungen und Beobachtungen

• Entitätsverwaltung: Projekte, Aufgaben, Personen, Ressourcen mit umfangreichen Metadaten

• Beziehungsabbildung: Abhängigkeiten, Zuständigkeiten, Blocker und Verbindungen

• Beobachtungsverfolgung: Kontextbezogene Notizen und Fortschrittsaktualisierungen

• Semantische Suche: Schnelles, lokales RAG-Matching über die native FTS5-Erweiterung von SQLite (MATCH und bm25()-Ranking) über Entitätsnamen, -typen und -beobachtungen

• Projektspezifisches Gedächtnis: Jedes Projekt erhält seine eigene memory.db. Der Server ermittelt das Projektverzeichnis in dieser Reihenfolge: die Umgebungsvariable GUARDIAN_PROJECT_ROOT, dann das Git-Toplevel des Arbeitsverzeichnisses, dann $XDG_DATA_HOME/project-guardian als gemeinsames Fallback außerhalb eines Git-Repositorys

• Zentraler Gedächtnisspiegel: Jeder Gedächtnis-Schreibvorgang wird zusätzlich in eine zentrale Datenbank unter ~/memory/memory.db synchronisiert, was eine aggregierte, durchsuchbare Karte über alle Projekte und ein Fallback ergibt, wenn eine Projektdatenbank nicht verfügbar ist. Lesezugriffe über read_graph und search_nodes führen beide Speicher zusammen, wobei Projekteinträge Vorrang haben

• Tägliche zentrale Backups: Beim ersten Synchronisieren eines Tages wird die zentrale Datenbank als Schnappschuss nach ~/memory/backup/ddmmyyyy_memory.db gesichert; die sieben neuesten Backups werden aufbewahrt und ältere automatisch entfernt. Beim ersten Start wird eine alte ~/memory.db im Home-Verzeichnis in das neue Layout migriert und zur Erstellung des ersten Backups verwendet

• Bedarfsgesteuerte Pre-Commit-Einrichtung: Beim Start wird nichts installiert. Rufen Sie setup_pre_commit auf, wenn Sie eine generierte .pre-commit-config.yaml und Git-Hooks im aktiven Projekt wünschen

• Bedarfsgesteuerte Weboberfläche: Starten Sie einen terminalgestalteten interaktiven Knotengraphen über start_ui (und close_ui/stop_ui, um den Port freizugeben), um den Projektzustand visuell zu verschieben, zu durchsuchen und zu erkunden. Nur für Desktop mit Mobile-Sperre (<768px-Overlay), stets sichtbarem Entitätsbrowser, gruppierten Bernstein-Orbs → aufklappbar zu cyanfarbenen Einzelbeobachtungen, cursor-gestreamtes GET /api/graph/stream?cursor=&limit=500 + react-window-virtuelle Liste, >1k-Physik-Einfrieren.

Optimierte Datenbankoperationen

• Zwei Speicher, eine Oberfläche: Jedes Projekt verwendet seine eigene memory.db; alle sieben Datenbanktools können mit database: "central" auch den zentralen Aggregatspeicher ansprechen

• Kern-CRUD: Wesentliche Datenbankoperationen (Abfragen, Einfügen, Aktualisieren, Löschen)

• SQL-Ausführung: Direkte Ausführung von SQL-Abfragen

• Datentransfer: Import/Export von CSV- und JSON-Dateien

• 34 Tools insgesamt: Sieben Datenbanktools, zehn Gedächtnistools, ein Leittool, zwölf Laufzeit-Begleiter-Tools und vier UI-/Stream-Tools (start_ui, close_ui, stop_ui, read_graph_stream)

Integration des Laufzeit-Begleiters

Das Repository enthält sechs guardian-*-AgentSkills und stellt ihre betrieblichen Fähigkeiten über typisierte MCP-Tools bereit:

AgentSkills stellen hostseitige Workflows und Anweisungen bereit. Die MCP-Laufzeit implementiert die entsprechenden Operationen direkt in TypeScript, mit Ausnahme des Container-Scans, der Trivy als begrenzten externen Prozess aufruft. Es wird kein generisches Skript- oder Shell-Ausführungstool bereitgestellt.

KI-Leitsystem

• 11 Ressourcen: Vorlagen, Best Practices, Projektstatus und Zustand der Begleiterfunktionen

• 27 Prompts: Umfassende vorgefertigte Workflows für alle Aspekte des Projektmanagements

• Experten-Leitlinien: Schritt-für-Schritt-Anweisungen für komplexe Operationen

• Kontextbezogene Hilfe: Adaptive Prompts basierend auf den Benutzerbedürfnissen

• Wissensbasis: Umfassende Projektmanagement-Weisheit

Erweiterte Funktionen

• Schema-Validierung: Umfassende Eingabevalidierung mit Zod-Schemas

• Fehlerbehandlung: Detaillierte Fehlermeldungen und elegante Fehlerbehandlung

• Verbindungsverwaltung: Begrenzter 20-Verbindungen-LRU-Cache mit WAL + synchronous=NORMAL + cache_size=-64000 + journal_size_limit=67108864 + temp_store=MEMORY + busy_timeout=5000, monatliches VACUUM (POST /api/vacuum) und Bereinigung beim Herunterfahren

• Dateiintegration: CSV- und SQL-Importe werden gestreamt; CSV-Schreibvorgänge verwenden begrenzte String-Assemblierung

• Ergebnislimits & Paginierung: Unbegrenzte rohe SELECT-Abfragen auf 10.000 Zeilen begrenzt; read_graph/readStore standardmäßig 5000 mit ?limit=&offset=, read_graph_stream-Cursor 500/Seite über GET /api/graph/stream?cursor=&limit=& + POST /api/vacuum, search_nodes auf 100 begrenzt (hybrides RRF k=60)

Enterprise-Funktionen

• TypeScript: Vollständig typisiert mit umfassender Fehlerbehandlung

• Eingabevalidierung: Zod-Schema-Validierung für alle Parameter

• Fehlerbehebung: Elegante Fehlerbehandlung mit detaillierten Fehlermeldungen

• Ressourcenverwaltung: Automatische Bereinigung von Verbindungen und Ressourcen

• Testen: Zehn Jest-Suiten mit 93 bestandenen Tests (WAL + Paginierung + close_ui + read_graph_stream + e2e-Vektor-Hybrid)

Voraussetzungen

• Node.js: >= 18.0.0

• npm: Neueste stabile Version

• SQLite3: Wird automatisch als Abhängigkeit installiert

• Redis: Optional; nur für cache_*-Tools über REDIS_URL erforderlich

• Trivy: Optional; nur für scan_container_image erforderlich

Installation

1. Repository klonen:

git clone https://github.com/1999AZZAR/project-guardian-mcp-server.git
cd project-guardian-mcp-server

2. Abhängigkeiten installieren:

npm install

3. Projekt erstellen: Wählen Sie zwischen Entwicklungs- oder Produktions-Build:

Für die Entwicklung (enthält Source Maps und vollständige TypeScript-Kompilierung):

npm run build

Für die Produktion (erstellt ein optimiertes, minifiziertes Bundle):

npm run build:prod

4. Testsuite ausführen:

npm test

5. Server starten:

npm start

Aktualisieren nach Änderungen

Wenn Sie neue Updates ziehen oder den Code ändern, müssen Sie den Server neu erstellen und Ihren MCP-Client (Cursor, Claude Desktop usw.) neu starten, damit die Änderungen wirksam werden:

1. Neuesten Code ziehen: git pull

2. Neue Abhängigkeiten installieren (falls vorhanden): npm install

3. Bundle neu erstellen: npm run build:prod

4. Wichtig: Starten Sie Ihre IDE oder die MCP-Verbindung neu, damit der Client die neu aktualisierten Tools und Prompts abrufen kann.

Verfügbare Tools

Dieser MCP-Server stellt derzeit 34 Tools bereit:

Datenbankoperationen (7 Tools)

Alle Datenbanktools akzeptieren einen optionalen database-Selektor: project (Standard) zielt auf die memory.db des aktiven Projekts, central auf den zentralen Aggregatspeicher unter ~/memory/memory.db.

execute_sql – SQL-Abfrage ausführen

Führt rohe SQL-Abfragen auf der ausgewählten Gedächtnisdatenbank aus.

Parameter:

• query (erforderlich): SQL-Abfragezeichenfolge

• parameters (optional): Array von Abfrageparametern

• database (optional): "project" oder "central", Standard "project"

query_data – Tabellendaten abfragen

Fragt Gedächtnistabellen mit Filterung und Paginierung ab.

Parameter:

• table (erforderlich): Tabellenname

• conditions (optional): WHERE-Bedingungen-Objekt

• limit (optional): Maximale Anzahl zurückzugebender Zeilen

• offset (optional): Anzahl zu überspringender Zeilen

• orderBy (optional): Spalte, nach der sortiert werden soll

• orderDirection (optional): Sortierrichtung ("ASC" oder "DESC")

• database (optional): "project" oder "central", Standard "project"

insert_data – Datensätze einfügen

Fügt Datensätze in eine Gedächtnistabelle ein.

Parameter:

• table (erforderlich): Tabellenname

• records (erforderlich): Array von einzufügenden Datensatzobjekten

• database (optional): "project" oder "central", Standard "project"

update_data – Datensätze aktualisieren

Aktualisiert Datensätze in einer Gedächtnistabelle.

Parameter:

• table (erforderlich): Tabellenname

• conditions (erforderlich): WHERE-Bedingungen für die zu aktualisierenden Datensätze

• updates (erforderlich): Zu aktualisierende Felder

• database (optional): "project" oder "central", Standard "project"

delete_data – Datensätze löschen

Löscht Datensätze aus einer Gedächtnistabelle.

Parameter:

• table (erforderlich): Tabellenname

• conditions (erforderlich): WHERE-Bedingungen für die zu löschenden Datensätze

• database (optional): "project" oder "central", Standard "project"

import_data – Daten importieren

Importiert Daten aus einer CSV- oder JSON-Datei in eine Gedächtnistabelle.

Parameter:

• table (erforderlich): Name der Zieltabelle

• filePath (erforderlich): Pfad zur Quelldatei

• format (optional): Dateiformat ("csv" oder "json")

• options (optional): Importoptionen (Trennzeichen, hasHeader)

• database (optional): "project" oder "central", Standard "project"

export_data – Daten exportieren

Exportiert Gedächtnistabellendaten in eine CSV- oder JSON-Datei.

Parameter:

• table (erforderlich): Name der Quelltabelle

• filePath (erforderlich): Pfad der Ausgabedatei

• format (optional): Ausgabeformat ("csv" oder "json")

• conditions (optional): WHERE-Bedingungen zum Filtern des Exports

• options (optional): Exportoptionen (delimiter, includeHeader)

• database (optional): "project" oder "central", Standard "project"

Memory- und Guidance-Tools (11 Tools)

initialize_memory - Memory-System initialisieren

Richtet das Schema und die Tabellen der Projekt-Memory-Datenbank ein.

Parameter: Keine

create_entity - Projekt-Entitäten erstellen

Erstellt Entitäten im Projekt-Wissensgraph (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• entities (erforderlich): Array von Entitätsobjekten

  • name: Name der Entität

  • entityType: Typ (project, task, person, resource)

  • observations: Array von Notizen über die Entität

create_relation - Entitätsbeziehungen erstellen

Erstellt Beziehungen zwischen Projektentitäten (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• relations (erforderlich): Array von Beziehungsobjekten

  • from: Name der Quellentität

  • to: Name der Zielentität

  • relationType: Beziehungstyp (depends_on, blocks, owns, usw.)

add_observation - Entitätsbeobachtungen hinzufügen

Fügt Projektentitäten Beobachtungen/Notizen hinzu (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• observations (erforderlich): Array von Beobachtungsobjekten

  • entityName: Name der Zielentität

  • contents: Array von Beobachtungszeichenfolgen zum Hinzufügen

delete_entity - Projektentitäten löschen

Entfernt Entitäten und ihre Beziehungen aus dem Projekt-Memory (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• entityNames (erforderlich): Array von zu löschenden Entitätsnamen

delete_observation - Entitätsbeobachtungen entfernen

Entfernt bestimmte Beobachtungen aus Entitäten (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• deletions (erforderlich): Array von Löschobjekten

  • entityName: Name der Zielentität

  • observations: Array von zu entfernenden Beobachtungszeichenfolgen

delete_relation - Entitätsbeziehungen löschen

Entfernt Beziehungen zwischen Projektentitäten (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• relations (erforderlich): Array von zu löschenden Beziehungsobjekten

  • from: Name der Quellentität

  • to: Name der Zielentität

  • relationType: Zu löschender Beziehungstyp

read_graph - Projekt-Wissensgraph lesen

Ruft den vollständigen Wissensgraph ab und führt die aktive Projektdatenbank mit dem zentralen Aggregat zusammen. Projekteinträge gewinnen gegenüber zentralen Einträgen mit demselben Namen. Unterstützt Paginierung.

Parameter:

• database (optional): "project" (Standard, zusammengeführt), "central" (nur zentral)

• limit (optional, 1-10000, Standard 5000): Maximale Anzahl zurückzugebender Entitäten/Beziehungen, ORDER BY updated_at DESC

• offset (optional, 0+): Zu überspringende Zeilen

search_nodes - Projektwissen durchsuchen

Durchsucht Entitäten und Beziehungen, die einer Abfrage entsprechen, über Namen, Typen und Inhalt, sowohl in der Projektdatenbank als auch im zentralen Aggregat. Verwendet FTS5 MATCH + bm25()-Ranking.

Parameter:

• query (erforderlich): Suchbegriff

• limit (optional, 1-100, Standard 20): Maximale Anzahl zurückzugebender bewerteter Entitäten

open_node - Entitätsdetails abrufen

Ruft detaillierte Informationen über Projektentitäten ab (unterstützt Einzel- oder Stapelverarbeitung).

Parameter:

• names (erforderlich): Array von abzurufenden Entitätsnamen

get_project_guidance - KI-Guidance abrufen

Ruft ein Projekt-Guidance-Framework auf, um spezialisierte Anweisungen und Checklisten für bestimmte Arbeitsabläufe zu erhalten. Dadurch kann die KI eigenständig etablierte Projektmanagement-Protokolle abrufen und befolgen.

Parameter:

• guidance_name (erforderlich): Name der Guidance (z. B. project-setup, sprint-planning)

• arguments (optional): Argumente, die vom jeweiligen Guidance-Framework benötigt werden

Runtime-Companion-Tools (12 Tools)

sync_central_memory

Kopiert den aktiven Projekt-Wissensgraph in die zentrale Memory-Datenbank (standardmäßig ~/memory/memory.db, überschreibbar mit GUARDIAN_CENTRAL_DB). Entitäten werden per Upsert eingefügt und Beziehungen dedupliziert, sodass die zentrale Datenbank eine durchsuchbare Karte über alle Projekte hinweg aufbaut. Jeder Memory-Schreibvorgang synchronisiert auch automatisch; rufen Sie dieses Tool auf, um eine Synchronisierung bei Bedarf zu erzwingen. Die erste Synchronisierung jedes Tages erstellt außerdem einen Snapshot der zentralen Datenbank und entfernt alte Backups, die über die neuesten sieben hinausgehen.

set_project_root

Wechselt die aktive Projekt-Memory-Datenbank zum angegebenen absoluten Projektpfad. Verwenden Sie dies beim Sitzungsstart, wenn der Server außerhalb des Projektverzeichnisses gestartet wurde, damit Memory in das Projekt geschrieben wird, anstatt in die gemeinsame Fallback-Datenbank.

• path (erforderlich): Absoluter Pfad zum Projektstamm. Innerhalb eines Git-Repositorys wird das Toplevel verwendet.

setup_pre_commit

Erstellt bei Bedarf eine .pre-commit-config.yaml im aktiven Projektstamm und installiert die Git-Hooks. Erfordert, dass pre-commit installiert ist. Die generierten .gitignore-Einträge sind bewusst breit gefasst: Neben memory.db ignoriert der Block gängige lokale Tool-Verzeichnisse wie .claude/, .vscode/, .idea/, .gemini/ und .cursor/ sowie .env-Dateien. Bereits in .gitignore vorhandene Einträge werden nie dupliziert. Der Server führt all dies beim Start nie automatisch aus.

get_session_context

Fasst aktive Aufgaben, offene Fehler, aktuelle Änderungen, Blocker und die nächste vorgeschlagene Aktion direkt aus dem Wissensgraph zusammen.

• limit (optional, 1-50, Standard 10): Maximale Einträge pro Ergebnisgruppe.

analyze_git_changes

Gibt exakte maschinenlesbare geänderte Pfade aus Git zurück, einschließlich Umbenennungen und optional nicht verfolgter Dateien.

• commit (optional): Analysiert einen einzelnen Commit gegenüber seinem Parent.

• since (optional, Standard 1): Analysiert Änderungen seit N Commits oder einem Git-Datum.

• includeUntracked (optional, Standard true): Bezieht nicht verfolgte Dateien in die Worktree-Analyse ein.

• maxFiles (optional, 1-500, Standard 100): Begrenzt die zurückgegebenen Pfade.

• commit und ein benutzerdefinierter since-Wert schließen sich gegenseitig aus.

inspect_untrusted_text

Normalisiert bis zu 256 KiB nicht vertrauenswürdigen Text und erkennt versteckte Formatierungen, Anweisungsüberschreibungen, Rollenimitation, verstecktes HTML/CSS, Markup für Remote-Exfiltration und codierte anweisungsähnliche Inhalte.

• text (erforderlich): Externer oder anderweitig nicht vertrauenswürdiger Inhalt.

• Die Erkennung ist heuristisch. Der zurückgegebene normalisierte Text bleibt nicht vertrauenswürdige Daten.

scan_project_secrets

Durchsucht eine arbeitsbereichsrelative Datei oder ein Verzeichnis nach wahrscheinlich hartcodierten Anmeldeinformationen. Ergebnisse enthalten nur Typ, relativen Dateipfad und Zeilennummer; übereinstimmende Werte werden nie zurückgegeben.

• path (optional, Standard .): Arbeitsbereichsrelatives Scan-Ziel.

• exclude (optional): Zusätzliche Verzeichnisnamen, die übersprungen werden sollen.

• maxFindings (optional, 1-500, Standard 100): Begrenzt die Funde.

• Absolute Pfade, Traversal, fehlende Pfade und Symlink-Escapes werden abgelehnt.

scan_container_image

Führt einen zeitlich begrenzten Trivy-Scan aus und gibt begrenzte HIGH/CRITICAL-Schwachstellenzusammenfassungen zurück.

• image (erforderlich): Container-Image-Referenz.

• maxFindings (optional, 1-500, Standard 100): Begrenzt die Funde.

• Erfordert Trivy. Image-Werte, die mit - beginnen, Leerzeichen enthalten oder Steuerzeichen enthalten, werden abgelehnt.

Redis-Cache-Tools

• cache_get: Liest einen mema:<category>:<name>-Schlüssel.

• cache_set: Speichert einen Wert bis zu 512 KiB mit optionalem ttlSeconds von 1 bis 604800.

• cache_delete: Löscht einen Schlüssel mit Namespace.

• cache_scan: Durchsucht per Cursor ein mema:*-Muster mit begrenzter Anzahl.

Projekt-Scanpfade sind auf das aktuelle Git-Workspace beschränkt. Redis-Tools verbinden sich erst bei Bedarf und geben einen Nichtverfügbarkeitsfehler zurück, wenn REDIS_URL nicht gesetzt ist. Container-Scans bleiben nicht verfügbar, bis Trivy installiert ist. Lesen Sie project-guardian://companions/catalog für den aktuellen Verfügbarkeitsstatus.

UI-Tools (4 Tools)

start_ui

Startet den bedarfsgesteuerten Project Guardian Web-UI-Server, um den Wissensgraph visuell im Browser zu durchsuchen. Er findet automatisch einen freien Port (Standard 3000, versucht bei Kollision 3001…) und gibt die lokale HTTP-URL zurück. Die UI bedient den CRT-thematisierten Force-Graph aus ui/dist mit korrektem Static-Path-Fallback (ui/dist → MCPservers/.../ui/dist).

• Parameter: Keine

• Rückgabe: UI Server successfully started on http://localhost:<port>

• Funktionen: Nur Desktop (Mobile-Gate bei <768px), Entitätsbrowser immer sichtbar, Beobachtungs-Orbs (gruppiertes Amber → erweitert zu Cyan), paginiert ?limit=&offset= auf /api/graph/*.

close_ui / stop_ui

Stoppt den Web-UI-Server, falls er läuft, und gibt den Port frei.

• Parameter: Keine

• Rückgabe: UI Server stopped

• stop_ui ist ein Alias für close_ui.

KI-Guidance-System

Project Guardian MCP enthält umfassende Ressourcen und Prompts, die KI-Modellen helfen, das Toolset für das Projektmanagement effektiv zu nutzen.

Verfügbare Ressourcen

Project Guardian bietet 11 wichtige Ressourcen, die KI-Modelle lesen können, um Projektmanagement-Konzepte zu verstehen, auf den Verfügbarkeitsstatus zuzugreifen und umfassende Projekteinblicke zu erhalten:

project-guardian://templates/entity-types

Standard-Entitätstypen für das Projektmanagement mit Beispielen und Nutzungsrichtlinien.

project-guardian://templates/relationship-types

Gängige Beziehungstypen zwischen Projektentitäten mit praktischen Beispielen.

project-guardian://templates/project-workflows

Standard-Workflows für die Verwendung der Project Guardian-Tools in verschiedenen Szenarien.

project-guardian://templates/best-practices

Umfassender Leitfaden zu Best Practices für ein effektives Projektwissensmanagement.

project-guardian://status/current-graph

Aktueller Zustand des Projekt-Wissensgraphs mit zusammenfassenden Statistiken.

project-guardian://cache/recent-activities

Kürzlich durchgeführte Projektmanagement-Aktivitäten und Aktualisierungen zur Fortschrittsverfolgung.

project-guardian://cache/workflow-templates

Häufig verwendete Workflow-Vorlagen mit Beispielen und Implementierungsanleitung.

project-guardian://metrics/project-stats

Statistische Übersicht über Projektentitäten, Beziehungen und Aktivitäten mit Health-Metriken.

project-guardian://cache/team-members

Zwischengespeicherte Informationen über Projektteammitglieder und ihre Rollen innerhalb der Organisation.

project-guardian://status/recent-changes

Kürzliche Ergänzungen, Aktualisierungen und Änderungen am Wissensgraph für Audit und Überwachung.

project-guardian://companions/catalog

Listet alle sechs Companions, ihre MCP-Tools, externen Voraussetzungen und die aktuelle Verfügbarkeit auf.

Verfügbare Prompts

Project Guardian bietet 27 Prompts für Projekt-Setup, Planung, Qualität, Betrieb und Incident-Workflows:

Kern-Projektmanagement

project-setup - Projektinitialisierung

Argumente:

• project_name (erforderlich): Name des Projekts

• team_members (optional): Kommagetrennte Liste der Teammitglieder

Bietet eine Schritt-für-Schritt-Anleitung zum Einrichten einer neuen Projektstruktur mit geeigneten Entitäten und Beziehungen.

sprint-planning - Sprint-Planung

Argumente:

• sprint_name (erforderlich): Name/Nummer des Sprints

• duration_days (optional): Sprintdauer in Tagen

Leitet durch eine umfassende Sprint-Planung, einschließlich Aufgabenzerlegung, Abhängigkeiten und Kapazitätsplanung.

progress-update - Fortschrittsverfolgung

Argumente:

• task_name (erforderlich): Name der zu aktualisierenden Aufgabe

• progress_notes (erforderlich): Beschreibung der Fortschrittsaktualisierung

Strukturierter Prozess zum Aktualisieren des Aufgabenfortschritts und zum Verwalten von Abhängigkeiten.

retrospective - Projekt-Retrospektive

Argumente:

• time_period (erforderlich): Zeitraum, der überprüft wird (z. B. "letzter Sprint", "Q1")

Umfassender Retrospektiven-Prozess, einschließlich Datenanalyse, Mustererkennung und Erstellung von Verbesserungsmaßnahmen.

Qualitäts- & Prozessmanagement

code-review - Code-Review-Prozess

Argumente:

• pull_request_title (erforderlich): Titel des zu überprüfenden Pull Requests

• reviewer_name (optional): Name des Reviewers

Strukturierter Code-Review-Prozess mit technischen Checklisten, Problemdokumentation und Genehmigungsworkflows.

bug-tracking - Bug-Management

Argumente:

• bug_description (erforderlich): Beschreibung des Fehlers oder Problems

• severity_level (optional): Kritisch, Hoch, Mittel oder Niedrig

Vollständiger Bug-Tracking-Workflow von der Erkennung bis zur Behebung mit Auswirkungsanalyse und Stakeholder-Kommunikation.

technical-debt-assessment - Technische Schuldenanalyse

Argumente:

• component_name (erforderlich): Name der zu bewertenden Komponente oder Codebasis

• assessment_scope (optional): Umfang der Bewertung (file, module, system)

Umfassende Identifizierung technischer Schulden, Priorisierung und Planung der Behebung.

Release- und Deployment-Verwaltung

release-planning - Release-Planung

Argumente:

• release_version (erforderlich): Versionsnummer für das Release (z. B. „v2.1.0")

• release_date (optional): Geplantes Releasedatum

Vollständiger Release-Planungsprozess einschließlich Qualitätskriterien, Risikobewertung und Deployment-Koordination.

Risiko- und Änderungsmanagement

risk-assessment - Risikomanagement

Argumente:

• risk_description (erforderlich): Beschreibung des Risikos

• impact_level (optional): Hohe, mittlere oder niedrige Auswirkung

Vollständiger Workflow zur Dokumentation von Risiken, Identifizierung von Auswirkungen und Entwicklung von Minderungsstrategien.

change-management - Änderungskontrolle

Argumente:

• change_description (erforderlich): Beschreibung der vorgeschlagenen Änderung

• impact_assessment (optional): Bewertung der Auswirkung als hoch, mittel oder niedrig

Strukturierter Änderungsmanagement-Prozess mit Auswirkungsanalyse, Genehmigungsworkflows und Implementierungsverfolgung.

Team- und Ressourcenverwaltung

team-productivity - Produktivitätsanalyse

Argumente:

• timeframe (erforderlich): Zu analysierender Zeitraum (week, month, quarter)

• focus_area (optional): Schwerpunktbereich (velocity, quality, collaboration)

Bewertung der Teamproduktivität mit Leistungskennzahlen, Ursachenanalyse und Verbesserungsplanung.

resource-allocation - Ressourcenplanung

Argumente:

• resource_type (erforderlich): Art der Ressource (human, infrastructure, budget)

• planning_horizon (optional): Planungszeitraum (sprint, quarter, year)

Optimierung der Ressourcenzuweisung mit Kapazitätsplanung, Lückenanalyse und Auslastungsverfolgung.

Dokumentation und Kommunikation

stakeholder-communication - Kommunikationsmanagement

Argumente:

• communication_type (erforderlich): Art der Kommunikation (status_update, issue_alert, milestone_reached)

• audience (optional): Zielgruppe (team, management, client, all)

Planung und Durchführung der Stakeholder-Kommunikation mit zielgruppenspezifischen Strategien und Wirksamkeitsverfolgung.

documentation-management - Dokumentationsaktualisierungen

Argumente:

• documentation_type (erforderlich): Art der Dokumentation (api, user_guide, technical_spec)

• update_reason (optional): Grund für die Dokumentationsaktualisierung

Dokumentationspflegeprozess mit Inhaltsplanung, Review-Workflows und Veröffentlichungskoordination.

Anforderungs- und Planungsverwaltung

requirements-gathering - Anforderungserhebung

Argumente:

• requirement_type (erforderlich): Art der Anforderungen (functional, non-functional, business, technical)

• stakeholders (optional): Kommagetrennte Liste der wichtigsten Stakeholder

Führt durch den umfassenden Anforderungserhebungsprozess mit Stakeholder-Management und Anforderungskategorisierung.

user-story-management - User-Story-Verwaltung

Argumente:

• feature_name (erforderlich): Name des Features oder Epics

• user_role (optional): Primäre Benutzerrolle (z. B. „customer", „admin", „developer")

Strukturierter Prozess zum Erstellen, Verwalten und Priorisieren von User Stories mit Abnahmekriterien und Abhängigkeiten.

Qualitäts- und technisches Management

testing-strategy - Entwicklung der Teststrategie

Argumente:

• application_type (erforderlich): Art der Anwendung (web, mobile, api, desktop)

• criticality_level (optional): Geschäftskritikalität (critical, high, medium, low)

Umfassende Entwicklung der Teststrategie einschließlich automatisierter Tests, Qualitätskriterien und risikobasierter Tests.

security-assessment - Sicherheitsbewertung

Argumente:

• assessment_scope (erforderlich): Umfang der Sicherheitsbewertung (application, infrastructure, data)

• compliance_requirements (optional): Compliance-Standards (GDPR, HIPAA, SOC2 usw.)

Framework für Sicherheitsbewertungen mit Schwachstellenmanagement, Compliance-Überprüfung und Implementierung von Sicherheitskontrollen.

performance-optimization - Leistungsoptimierung

Argumente:

• performance_metric (erforderlich): Primäre zu optimierende Kennzahl (response_time, throughput, resource_usage)

• optimization_goal (optional): Konkretes Leistungsziel oder Verbesserungsprozentsatz

Einrichtung des Leistungsmonitorings, Identifizierung von Engpässen und Implementierung von Optimierungen mit kontinuierlichem Monitoring.

ci-cd-setup - CI/CD-Pipeline-Einrichtung

Argumente:

• pipeline_type (erforderlich): Art der Pipeline (build, test, deploy, full_ci_cd)

• target_platform (optional): Deployment-Ziel (aws, azure, gcp, kubernetes, heroku)

Vollständige CI/CD-Pipeline-Einrichtung einschließlich Qualitätskriterien, Rollback-Verfahren und Sicherheitsintegration.

architecture-review - Architektur-Review

Argumente:

• architecture_type (erforderlich): Art der Architektur (microservices, monolithic, serverless, hybrid)

• review_focus (optional): Primärer Schwerpunktbereich (scalability, security, maintainability, performance)

Framework für Architekturbewertungen mit Entwurfsmusteranalyse, Bewertung des Technologie-Stacks und Verbesserungsempfehlungen.

Wissens- und Teamverwaltung

knowledge-transfer - Wissenstransfer

Argumente:

• knowledge_domain (erforderlich): Wissensdomäne (technical, process, business)

• transfer_recipients (optional): Wer das Wissen erhalten soll (team, individual, department)

Planung und Durchführung des Wissenstransfers mit Sitzungsverwaltung, Dokumentation und Wirksamkeitsvalidierung.

vendor-management - Anbieterverwaltung

Argumente:

• vendor_type (erforderlich): Art des Anbieterdienstes (cloud, development, consulting, infrastructure)

• contract_value (optional): Vertragswertbereich (small, medium, large, enterprise)

Verwaltung der Anbieterbeziehungen einschließlich Vertragsverfolgung, Leistungsüberwachung und Kostenoptimierung.

Vorfall- und Krisenmanagement

incident-response - Vorfallreaktion

Argumente:

• incident_severity (erforderlich): Schweregrad (critical, high, medium, low)

• incident_type (optional): Art des Vorfalls (security, performance, functionality, availability)

Framework für die Vorfallreaktion mit Eindämmung, Wiederherstellung, Ursachenanalyse und Überprüfung nach dem Vorfall.

Finanz- und Ressourcenverwaltung

cost-management - Kostenmanagement

Argumente:

• cost_category (erforderlich): Primäre Kostenkategorie (infrastructure, personnel, tools, licenses)

• budget_constraint (optional): Budgetbeschränkungsgrad (strict, flexible, unlimited)

Kostenüberwachung, Optimierungsstrategien und Budgetverwaltung mit Prognose und Berichterstattung.

Kunden- und Innovationsmanagement

customer-feedback - Kundenfeedback-Verwaltung

Argumente:

• feedback_channel (erforderlich): Primärer Feedbackkanal (survey, support, reviews, analytics)

• feedback_focus (optional): Schwerpunktbereich (usability, features, performance, support)

Erfassung von Kundenfeedback, Analyse und Aktionsplanung mit kontinuierlichen Verbesserungszyklen.

innovation-planning - Innovationsplanung

Argumente:

• innovation_type (erforderlich): Art der Innovation (product, process, technology, business_model)

• risk_tolerance (optional): Risikotoleranzgrad (conservative, moderate, aggressive)

Innovationsmanagement-Framework mit Ideengenerierung, Experimentieren und Erfolgsmessung.

Wie KI-Modelle die Anleitung nutzen

1. Entdeckung: Verfügbare Ressourcen und Prompts auflisten, um die Fähigkeiten zu verstehen

2. Lernen: Relevante Ressourcen lesen, um Projektmanagement-Konzepte zu verstehen

3. Planung: Geeignete Prompts für komplexe Workflows verwenden

4. Ausführung: Strukturierter Anleitung folgen, um Tools effektiv zu nutzen

5. Überprüfung: Ergebnisse prüfen und bei Bedarf iterieren Dieses Anleitungssystem stellt sicher, dass KI-Modelle mithilfe des Project-Guardian-Toolsets fachkundige Projektmanagement-Unterstützung bieten können.

Verhaltensprotokoll (Systemregeln)

Jede prompts/get-Antwort dieses MCP-Servers enthält ein gemeinsames Verhaltensprotokoll als Systemnachricht (implementiert in src/prompts/behavioral-protocol.ts). Dieses Protokoll erzwingt:

• Minimaler, produktionsreifer, selbst dokumentierender Code mit einem Security-First-Ansatz.

• Keine Schlagwörter, unnötigen Emojis oder Füllwörter; direkte, technisch präzise Antworten.

• Adaptive Antworttiefe basierend auf der Anfrage des Benutzers (kurze Antworten vs. komplexe Aufschlüsselungen).

• Konsistente Verwendung validierter Best Practices für Systeme, Programmierung, UI/UX und Design.

Clients, die diesen MCP-Server integrieren, sollten die erste Systemnachricht als die maßgeblichen Regeln für jedes nachgelagerte Modell behandeln, das diese Prompts verwendet.

Verwendungsbeispiele

Einrichtung von Project Guardian

// Initialize the project memory system
const initResult = await mcpClient.callTool('initialize_memory', {});

// Create your first project entities
const entityResult = await mcpClient.callTool('create_entity', {
  entities: [
    {
      name: 'web_platform',
      entityType: 'project',
      observations: ['Main web application platform', 'React + Node.js stack', 'Q2 2024 delivery']
    },
    {
      name: 'user_authentication',
      entityType: 'feature',
      observations: ['OAuth2 implementation', 'Google/GitHub providers', 'JWT tokens']
    }
  ]
});

// Establish project relationships
const relationResult = await mcpClient.callTool('create_relation', {
  relations: [
    {
      from: 'user_authentication',
      to: 'web_platform',
      relationType: 'part_of'
    }
  ]
});

Projektmanagement-Workflow

// Add progress observations
await mcpClient.callTool('add_observation', {
  observations: [
    {
      entityName: 'user_authentication',
      contents: [
        'Completed OAuth2 setup for Google provider',
        'JWT implementation finished',
        'Unit tests passing at 95% coverage'
      ]
    }
  ]
});

// Search project knowledge
const searchResult = await mcpClient.callTool('search_nodes', {
  query: 'authentication'
});

// Read entire project knowledge graph
const graphResult = await mcpClient.callTool('read_graph', {});

// Get detailed entity information
const entityDetails = await mcpClient.callTool('open_node', {
  names: ['user_authentication', 'web_platform']
});

Datenbankoperationen

// Execute custom SQL queries
const sqlResult = await mcpClient.callTool('execute_sql', {
  query: 'SELECT * FROM entities WHERE entity_type = ?',
  parameters: ['project']
});

// Query project data
const queryResult = await mcpClient.callTool('query_data', {
  table: 'entities',
  conditions: { entity_type: 'task' },
  limit: 10
});

// Import/export data
const importResult = await mcpClient.callTool('import_data', {
  table: 'project_data',
  filePath: './project_backup.csv',
  format: 'csv'
});

Konfiguration

Umgebungsvariablen

Der Server liest diese Variablen beim Start:

MCP-Clients starten Server mit ihrem eigenen Arbeitsverzeichnis, das oft Ihr Home-Ordner und nicht das Projekt ist, an dem Sie arbeiten. In dieser Situation kann die Git-Erkennung das Projekt nicht finden, und jede Sitzung schreibt in die gemeinsame Fallback-Datenbank. Es gibt zwei Möglichkeiten, dies zu beheben:

1. Setzen Sie GUARDIAN_PROJECT_ROOT in der MCP-Konfiguration des Projekts (siehe die Client-Beispiele unten).

2. Rufen Sie das Tool set_project_root mit dem absoluten Projektpfad zu Beginn der Sitzung auf – keine Konfigurationsänderungen erforderlich. Der Wechsel gilt für den laufenden Server; setzen Sie die Umgebungsvariable, wenn Sie möchten, dass sie automatisch für jede zukünftige Sitzung gilt.

Optionale Laufzeitdienste

Redis ist optional und wird beim Start nie kontaktiert. Konfigurieren Sie Redis nur, wenn Cache-Tools benötigt werden:

{
  "env": {
    "REDIS_URL": "redis://localhost:6379/0"
  }
}

Trivy wird über PATH gefunden, wenn scan_container_image aufgerufen wird. Fehlendes Redis oder Trivy wirkt sich nur auf die zugehörigen Tools aus; die Tools für Memory, Datenbank, Guidance, Session, Git, Wall und Project-Secret bleiben verfügbar.

Der Companion-Katalog meldet für jede Runtime-Fähigkeit available, optional oder unavailable. Der Server verwendet den stdio-Transport und stellt keinen HTTP-Listener bereit.

Für Cursor IDE

Fügen Sie diesen Server zu Ihrer Cursor-MCP-Konfiguration (~/.cursor/mcp.json) hinzu. Ersetzen Sie den Wert von GUARDIAN_PROJECT_ROOT durch das Projekt, zu dem diese Konfiguration gehört:

{
  "mcpServers": {
    "project-guardian": {
      "command": "node",
      "args": ["/path/to/project-guardian-mcp-server/dist/index.js"],
      "env": {
        "GUARDIAN_PROJECT_ROOT": "/path/to/your/project"
      }
    }
  }
}

Für Claude Desktop

Fügen Sie diesen Server nach demselben Muster zu Ihrer Claude-Desktop-Konfiguration (claude_desktop_config.json) hinzu:

{
  "mcpServers": {
    "project-guardian": {
      "command": "node",
      "args": ["/path/to/project-guardian-mcp-server/dist/index.js"],
      "env": {
        "GUARDIAN_PROJECT_ROOT": "/path/to/your/project"
      }
    }
  }
}

Projektstruktur

project-guardian-mcp-server/
├── src/
│   ├── index.ts              # Main entry point
│   ├── server.ts             # MCP server orchestrator
│   ├── memory-manager.ts     # Knowledge graph and FTS5 RAG semantic search
│   ├── sqlite-manager.ts     # Database operations and connection management
│   ├── import-export.ts      # CSV/JSON data import and export functionality
│   ├── ui-manager.ts         # On-Demand Web UI server and port finder
│   ├── types.ts              # TypeScript type definitions and schemas
│   ├── handlers/
│   │   └── request-handlers.ts # Central tool execution dispatcher
│   ├── tools/
│   │   ├── tool-registry.ts     # Tool definitions and listing
│   │   ├── database-tools.ts    # Database operation tool schemas
│   │   ├── memory-tools.ts      # Memory management tool schemas
│   │   ├── guidance-tools.ts    # Guidance tool schema
│   │   └── runtime-tools.ts     # Companion runtime tool schemas
│   ├── runtime/
│   │   ├── path-guard.ts        # Workspace path containment
│   │   └── runtime-capabilities.ts # Native companion implementations
│   ├── resources/
│   │   ├── resource-registry.ts  # Resource definitions and handlers
│   │   ├── resource-definitions.ts # Static resource metadata
│   │   ├── resource-handlers.ts   # Dynamic resource content generation
│   │   └── companion-catalog.ts   # Companion capability health
│   └── prompts/
│       ├── prompt-registry.ts       # Prompt definitions and handlers
│       ├── prompt-definitions.ts    # Static prompt metadata
│       ├── prompt-handlers.ts       # Dynamic prompt content generation
│       └── behavioral-protocol.ts   # Shared Behavioral Protocol system prompt
├── ui/                       # On-Demand Web UI frontend (Vite/React)
│   ├── src/
│   │   ├── App.tsx           # Main CRT-themed node graph visualization
│   │   ├── main.tsx          # React DOM entry point
│   │   └── index.css         # Styling, CRT scanlines, and CSS variables
│   └── vite.config.ts        # Vite build configuration
├── __tests__/                # Comprehensive test suite
│   ├── tool-registry.test.ts
│   ├── resource-registry.test.ts
│   ├── prompt-registry.test.ts
│   ├── request-handlers.test.ts
│   ├── runtime-capabilities.test.ts
│   ├── import-export.test.ts
│   ├── sqlite-manager.test.ts
│   └── bug-fixes.test.ts
├── skills/                   # Six distributable guardian-* AgentSkills
├── dist/                     # Ignored production build output
├── memory.db                 # Ignored local SQLite state, created on first run
├── package.json              # Project dependencies and scripts
├── package.prod.json         # Production-only dependencies for smaller bundle
├── tsconfig.json            # TypeScript configuration
├── jest.config.js           # Test configuration
└── README.md                # This documentation

Wichtige Komponenten

• server.ts: MCP-Serverlebenszyklus, Transport, Handler und Koordination des Herunterfahrens

• handlers/request-handlers.ts: Zentraler Dispatcher, der Tool-Aufrufe an die zuständigen Manager weiterleitet

• tools/: System zur Definition und Registrierung von Tools (insgesamt 34 Tools)

  • tool-registry.ts: Listet alle verfügbaren Tools auf (7 DB + 10 Memory + 1 Guidance + 12 Runtime + 3 UI)

  • database-tools.ts: Schemas für Datenbankoperationen (7 Tools)

  • memory-tools.ts: Schemas für die Memory-Verwaltung (10 Tools)

  • guidance-tools.ts: Schema für das autonome Guidance-Tool (1 Tool)

  • runtime-tools.ts: Typisierte Schemas für Companion-Fähigkeiten (12 Tools)

• runtime/: Workspace-Guards und Implementierungen der Companion-Runtime

• resources/: System zur Ressourcenverwaltung (insgesamt 11 Ressourcen)

  • resource-registry.ts: Auflistung von Ressourcen und Bereitstellung von Inhalten

  • resource-definitions.ts: Statische Ressourcenmetadaten

  • resource-handlers.ts: Dynamische Inhaltsgenerierung

• prompts/: System zur Prompt-Verwaltung (insgesamt 27 Prompts)

  • prompt-registry.ts: Auflistung von Prompts und Bereitstellung von Inhalten

  • prompt-definitions.ts: Statische Prompt-Metadaten

  • prompt-handlers.ts: Dynamische Prompt-Generierung mit Kontext

  • behavioral-protocol.ts: Zentrale Systemnachricht des Behavioral Protocol, die von allen Prompts verwendet wird

• memory-manager.ts: Wissensgraph-Operationen für Entitäten, Beziehungen und Beobachtungen

• sqlite-manager.ts: Datenbankabstraktion mit begrenztem Verbindungs-Caching und Schemaverwaltung

• import-export.ts: Datenübertragungs-Dienstprogramme für CSV, JSON und SQL

• types.ts: Zod-Schemas für Eingabevalidierung und TypeScript-Typsicherheit

• skills/: Agentenseitige Workflows, Skripte, Referenzen und Assets für die sechs Companion-Pakete

Lokaler Zustand

memory.db und seine memory.db-*-Sidecar-Dateien sind Laufzeitzustand und werden von Git ignoriert. Jedes Projekt führt seine eigene Datenbank an seinem aufgelösten Projektstammverzeichnis (siehe Umgebungsvariablen); Projekte außerhalb eines Git-Repositorys ohne explizites Stammverzeichnis teilen sich die Fallback-Datenbank unter $XDG_DATA_HOME/project-guardian. Zusätzlich wird jeder Memory-Schreibvorgang in die zentrale Datenbank unter ~/memory/memory.db gespiegelt, die eine projektübergreifende Zusammenführung darstellt: Das Löschen einer Entität in einem Projekt entfernt sie nicht aus der zentralen Kopie; behandeln Sie die zentrale Datenbank daher als durchsuchbares Aggregat und nicht als projektbezogenes Backup. Tägliche Snapshots befinden sich in ~/memory/backup/. Ein Klon startet ohne Projekt-Memory; der Server erstellt die Datenbank und das Schema beim ersten Lauf lokal. Sichern oder exportieren Sie Memory explizit, wenn es zwischen Maschinen übertragen werden muss. Übergeben Sie die Datenbank niemals an die Versionskontrolle, da Beobachtungen privaten Projektkontext enthalten können.

Die Datenbank-Tools (execute_sql, query_data, insert_data, update_data, delete_data, import_data, export_data) akzeptieren einen database-Selektor: project (Standard) zielt auf die aktive Projektdatenbank, central auf das Aggregat.

Entwicklung

1. Repository klonen:

git clone https://github.com/1999AZZAR/project-guardian-mcp-server.git
cd project-guardian-mcp-server

2. Abhängigkeiten installieren:

npm install

3. Projekt erstellen: Für aktive Entwicklung (mit Dateiüberwachung):

npm run dev

Für einen Standard-Build:

npm run build

Für einen produktionsoptimierten Build:

npm run build:prod

4. Tests ausführen:

npm test

5. Server starten:

npm start

Lizenz

MIT-Lizenz – Einzelheiten finden Sie in der Datei LICENSE.