Encrypted SQLite MCP Server

MCP-Server für verschlüsselte SQLite-Datenbanken

Ein Model Context Protocol (MCP)-Server für die Arbeit mit verschlüsselten SQLite-Datenbanken unter Verwendung von SQLCipher. Dieser Server bietet Werkzeuge zum Lesen von Datenbankstrukturen, Abfragen von Tabellen und Durchführen von CRUD-Operationen auf verschlüsselten SQLite-Datenbanken.

Kompatibel mit allen MCP-Clients (Cursor, Claude Desktop und andere).

Funktioniert mit verschlüsselten Datenbanken von: MoneyMoney, 1Password, Signal, WhatsApp, Firefox, Telegram, KeePass und anderen Anwendungen, die SQLCipher-Verschlüsselung verwenden.

Funktionen

• Unterstützung für verschlüsselte SQLite-Datenbanken: Funktioniert mit SQLCipher 4 verschlüsselten Datenbanken – das wichtigste Unterscheidungsmerkmal dieses MCP-Servers

• Verschlüsselte Passphrasen: Unterstützung für AES-256-GCM-verschlüsselte Passphrasen mit macOS-Keychain-Integration

• Datenbank-Exploration: Tabellen, Spalten, Indizes und Schema-Metadaten auflisten

• Abfrageunterstützung: Beliebige SQL-Abfragen ausführen (SELECT, INSERT, UPDATE, DELETE, DDL)

• CRUD-Operationen: Zeilen einfügen, aktualisieren und löschen mit Filterung

• Konfigurierbare Cipher-Profile: Unterstützung für verschiedene SQLCipher-Konfigurationen

• MCP-Protokoll: Vollständige Implementierung des Model Context Protocol über STDIO

• Sicherheit: Validierung von SQL-Bezeichnern zur Verhinderung von SQL-Injection

• Debug-Modus: Optionale Debug-Ausgabe über die Umgebungsvariable MCP_DEBUG

• Eingabevalidierung: Umfassende Validierung für Limits, Offsets und Bezeichner

Related MCP server: mcp-sqlite

Warum verschlüsseltes SQLite?

Viele beliebte Anwendungen verwenden verschlüsselte SQLite-Datenbanken (SQLCipher), um sensible Daten zu schützen. Dieser MCP-Server ist speziell für die Arbeit mit diesen verschlüsselten Datenbanken konzipiert.

Anwendungen, die verschlüsselte SQLite-Datenbanken verwenden

• MoneyMoney (macOS): Finanzverwaltungs-App mit verschlüsselten lokalen Datenbanken

• 1Password: Passwortmanager, der SQLCipher für die lokale Tresor-Speicherung verwendet

• Signal: Verschlüsselte Messaging-App mit SQLCipher-geschützten Nachrichtendatenbanken

• WhatsApp: Messaging-App, die verschlüsseltes SQLite für die lokale Nachrichtenspeicherung verwendet

• Firefox: Browser, der SQLCipher für verschlüsselte Login-Datenbanken verwendet

• Telegram: Messaging-App mit verschlüsselter lokaler Datenbankspeicherung

• KeePass: Passwortmanager, der verschlüsselte SQLite-Datenbankdateien unterstützt

Wenn Sie auf Daten aus einer dieser Anwendungen oder anderen SQLCipher-verschlüsselten Datenbanken zugreifen müssen, bietet dieser MCP-Server die benötigten Werkzeuge. Beachten Sie, dass Sie die Passphrase der verschlüsselten Datenbank benötigen.

Anforderungen

• Java 21 oder höher (JDK)

• Gradle (Wrapper enthalten)

• SQLite-JDBC-Treiber mit Verschlüsselungsunterstützung (sqlite-jdbc-3.50.1.0.jar von sqlite-jdbc-crypt)

Schnellstart

Cursor (Ein-Klick-Installation)

Der einfachste Weg, diesen MCP-Server in Cursor zu installieren, ist über den Cursor MCP Store:

1. Besuchen Sie cursor.store/mcp/rosch100/mcp-encrypted-sqlite

2. Klicken Sie auf "Add to Cursor"

3. Folgen Sie den Anweisungen, um Ihren Datenbankpfad und Ihre Passphrase zu konfigurieren

Andere MCP-Clients

Dieser Server funktioniert mit jedem MCP-kompatiblen Client. Siehe Abschnitt Konfiguration unten für Einrichtungsanweisungen.

Installation

Docker (Empfohlen)

Verwenden Sie das vorgefertigte Docker-Image aus der GitHub Container Registry:

docker pull ghcr.io/rosch100/mcp-encrypted-sqlite:latest

Schnellstart: Siehe DOCKER_QUICKSTART.md für die Docker-Desktop-Einrichtung.

Detaillierte Konfiguration: Siehe DOCKER_CONFIGURATION.md für erweiterte Optionen.

Aus dem Quellcode

1. Klonen Sie das Repository:

   git clone https://github.com/rosch100/mcp-encrypted-sqlite.git

   cd mcp-encrypted-sqlite

2. Bauen Sie das Projekt:

   ./gradlew build installDist

Der Build-Prozess lädt automatisch sqlite-jdbc-3.50.1.0.jar von sqlite-jdbc-crypt releases herunter und platziert es im Verzeichnis libs/.

Die ausführbare Datei ist verfügbar unter build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite.

Konfiguration

Dieser MCP-Server funktioniert mit jedem MCP-kompatiblen Client (Cursor, Claude Desktop usw.). Das Konfigurationsformat folgt der Model Context Protocol-Spezifikation.

Der Server kommuniziert über STDIO (Standard-Eingabe/Ausgabe). Fügen Sie die folgende Konfiguration zur Konfigurationsdatei Ihres MCP-Clients hinzu:

Speicherorte der Konfigurationsdateien:

• Cursor: ~/.cursor/mcp.json

• Claude Desktop (macOS): ~/Library/Application Support/Claude/claude_desktop_config.json

• Claude Desktop (Windows): %APPDATA%\Claude\claude_desktop_config.json

• Andere Clients: Siehe Dokumentation Ihres Clients

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ]
    }
  }
}

Optionale Parameter:

• transport: Standardmäßig "stdio" (kann weggelassen werden)

• cwd: Nicht erforderlich bei Verwendung absoluter Pfade (kann weggelassen werden)

• immutable: Optionaler boolescher Wert im --args-JSON. Wenn true, wird die Datenbank mit der SQLite-URI file:…?immutable=1 geöffnet (keine Dateisperren). Verwenden Sie dies, um einen Blick auf Datenbanken zu werfen, die exklusiv von einer anderen App gesperrt sind (z. B. MoneyMoney). Alle Schreibwerkzeuge/SQL sind in diesem Modus deaktiviert (insert_or_update / delete_rows weggelassen; execute_sql akzeptiert nur schreibgeschützte Anweisungen).

• env: Nur erforderlich, wenn Java nicht in Ihrem System-PATH ist oder für eine benutzerdefinierte Java-Installation:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ],
      "env": {
        "JAVA_HOME": "/path/to/java/home"
      }
    }
  }
}

Docker-Konfiguration

Klartext-Passphrase

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "/path/to/your/database.sqlite:/data/database.sqlite:ro",
        "ghcr.io/rosch100/mcp-encrypted-sqlite:latest",
        "--args",
        "{\"db_path\":\"/data/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ]
    }
  }
}

Verschlüsselte Passphrase (Empfohlen)

Bei Verwendung verschlüsselter Passphrasen müssen Sie den Verschlüsselungsschlüssel als Umgebungsvariable übergeben:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "MCP_SQLITE_ENCRYPTION_KEY=your-encryption-key",
        "-v", "/path/to/your/database.sqlite:/data/database.sqlite:ro",
        "ghcr.io/rosch100/mcp-encrypted-sqlite:latest",
        "--args",
        "{\"db_path\":\"/data/database.sqlite\",\"passphrase\":\"encrypted:your-encrypted-passphrase\"}"
      ]
    }
  }
}

Wichtige Hinweise:

• Das -e-Flag muss vor dem -v-Flag stehen

• macOS Keychain ist von Docker-Containern aus NICHT zugänglich – übergeben Sie den Verschlüsselungsschlüssel explizit

• Holen Sie sich Ihren Verschlüsselungsschlüssel: security find-generic-password -s "mcp-encrypted-sqlite" -a "encryption-key" -w

• Die Datenbankdatei ist standardmäßig schreibgeschützt (:ro) eingebunden. Entfernen Sie :ro, wenn Sie Schreibzugriff benötigen

Sicherheitswarnung: Das Speichern sowohl des Verschlüsselungsschlüssels als auch der verschlüsselten Passphrase als Klartext in Ihrer Konfigurationsdatei ist ein Sicherheitsrisiko. Siehe DOCKER_CONFIGURATION.md für sichere Alternativen.

Benutzerdefiniertes Cipher-Profil

Überschreiben Sie die Standardeinstellungen von SQLCipher 4, indem Sie ein cipherProfile in das Konfigurations-JSON aufnehmen:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\",\"cipherProfile\":{\"name\":\"SQLCipher 4 defaults\",\"pageSize\":4096,\"kdfIterations\":256000,\"hmacAlgorithm\":\"HMAC_SHA512\",\"kdfAlgorithm\":\"PBKDF2_HMAC_SHA512\"}}"
      ]
    }
  }
}

Hinweis: Alle Felder in cipherProfile sind optional – geben Sie nur die an, die Sie gegenüber den Standardeinstellungen überschreiben möchten. Sie können cipherProfile auch in einzelnen Tool-Aufrufen angeben, aber es wird empfohlen, es einmal in der MCP-Serverkonfiguration für Konsistenz zu konfigurieren.

Verschlüsselte Passphrasen

Für erhöhte Sicherheit können Sie Passphrasen in verschlüsselter Form speichern. Der Server verwendet AES-256-GCM-Verschlüsselung, die authentifizierte Verschlüsselung bietet und sowohl sicher als auch schnell ist.

macOS Keychain (Empfohlen für macOS)

1. Schlüssel generieren und in der Keychain speichern: Führen Sie aus: ./store-key-in-keychain.sh --generate

2. Passphrase verschlüsseln: Führen Sie aus: ./encrypt-passphrase.sh "ihre-klartext-passphrase"

Der Schlüssel wird automatisch aus der Keychain geladen, wenn keine Umgebungsvariable gesetzt ist.

Vorteile:

• Der Schlüssel wird sicher von macOS verschlüsselt und gespeichert

• Keine Umgebungsvariablen erforderlich

• Automatische Entsperrung mit dem macOS-Benutzerpasswort

• Funktioniert systemweit für alle Anwendungen

Umgebungsvariable (Plattformübergreifend)

1. Verschlüsselungsschlüssel generieren: Führen Sie aus: java -cp build/libs/mcp-encrypted-sqlite-VERSION.jar com.example.mcp.sqlite.config.PassphraseEncryption

2. Verschlüsselungsschlüssel setzen: Führen Sie aus: export MCP_SQLITE_ENCRYPTION_KEY="<ihr-generierter-schlüssel>"

3. Passphrase verschlüsseln: Führen Sie aus: java -cp build/libs/mcp-encrypted-sqlite-VERSION.jar com.example.mcp.sqlite.util.EncryptPassphrase "ihre-klartext-passphrase"

Verwendung

Verwenden Sie die verschlüsselte Passphrase (mit Präfix encrypted:) in Ihrer Konfiguration:

Auf macOS mit Keychain (empfohlen):

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"encrypted:<encrypted-passphrase>\"}"
      ]
    }
  }
}

Hinweis: Kein env-Abschnitt erforderlich – der Schlüssel wird automatisch aus der macOS-Keychain geladen.

Mit Umgebungsvariable (plattformübergreifend):

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"encrypted:<encrypted-passphrase>\"}"
      ],
      "env": {
        "MCP_SQLITE_ENCRYPTION_KEY": "<your-encryption-key>"
      }
    }
  }
}

Wichtige Sicherheitshinweise:

• Der Verschlüsselungsschlüssel MUSS verfügbar sein (macOS Keychain oder Umgebungsvariable MCP_SQLITE_ENCRYPTION_KEY)

• Der Server erkennt automatisch verschlüsselte Passphrasen (beginnend mit encrypted:) und entschlüsselt sie

• Verwenden Sie PassphraseEncryption.generateKey(), um starke Schlüssel zu generieren (256 Bit / 32 Bytes)

• AES-256-GCM bietet authentifizierte Verschlüsselung

• Schwache Schlüssel werden automatisch abgelehnt

Verfügbare Werkzeuge

list_tables

Listet alle Tabellen in der Datenbank auf. Standardmäßig nur Tabellennamen, mit include_columns=true auch Spaltendetails.

Parameter:

• db_path (optional, wenn konfiguriert): Pfad zur Datenbankdatei

• passphrase (optional, wenn konfiguriert): Datenbank-Passphrase

• include_columns (optional, Standard: false): Wenn true, werden auch Spaltendetails zurückgegeben

Beispiel:

{
  "name": "list_tables",
  "arguments": {
    "include_columns": true
  }
}

get_table_data

Liest Daten aus einer Tabelle mit optionaler Filterung, Spaltenauswahl und Paginierung.

Parameter:

• table (erforderlich): Tabellenname

• columns (optional): Array von Spaltennamen zur Auswahl

• filters (optional): Objekt mit Spalten-Wert-Paaren zur Filterung

• limit (optional, Standard: 200): Maximale Anzahl von Zeilen

• offset (optional, Standard: 0): Offset für Paginierung

Beispiel:

{
  "name": "get_table_data",
  "arguments": {
    "table": "accounts",
    "columns": ["id", "name", "balance"],
    "filters": {"status": "active"},
    "limit": 50,
    "offset": 0
  }
}

execute_sql

Führt beliebige SQL-Anweisungen aus (SELECT, INSERT, UPDATE, DELETE, DDL).

Sicherheitswarnung: Dieses Werkzeug führt rohes SQL ohne Parametrisierung aus. Verwenden Sie es nur mit vertrauenswürdigem SQL oder stellen Sie sicher, dass vor dem Aufruf dieses Werkzeugs eine ordnungsgemäße Validierung und Bereinigung durchgeführt wird. Für sicherere Operationen verwenden Sie die anderen Werkzeuge (get_table_data, insert_or_update, delete_rows), die parametrisierte Abfragen verwenden.

Parameter:

• sql (erforderlich): Auszuführende SQL-Anweisung

Beispiel:

{
  "name": "execute_sql",
  "arguments": {
    "sql": "SELECT COUNT(*) FROM transactions WHERE amount > 1000"
  }
}

insert_or_update

Führt UPSERT-Operationen durch (INSERT oder UPDATE bei Konflikt).

Parameter:

• table (erforderlich): Tabellenname

• primary_keys (erforderlich): Array von Primärschlüssel-Spaltennamen

• rows (erforderlich): Array von Zeilenobjekten zum Einfügen/Aktualisieren

Beispiel:

{
  "name": "insert_or_update",
  "arguments": {
    "table": "accounts",
    "primary_keys": ["id"],
    "rows": [
      {"id": 1, "name": "Account 1", "balance": 1000.0},
      {"id": 2, "name": "Account 2", "balance": 2000.0}
    ]
  }
}

delete_rows

Löscht Zeilen aus einer Tabelle basierend auf Filtern.

Parameter:

• table (erforderlich): Tabellenname

• filters (erforderlich): Objekt mit Spalten-Wert-Paaren zur Filterung

Beispiel:

{
  "name": "delete_rows",
  "arguments": {
    "table": "transactions",
    "filters": {"status": "cancelled"}
  }
}

get_table_schema

Ruft detaillierte Schema-Informationen für eine Tabelle ab (Spalten, Indizes, Fremdschlüssel, Einschränkungen).

Parameter:

• table (erforderlich): Tabellenname

Beispiel:

{
  "name": "get_table_schema",
  "arguments": {
    "table": "accounts"
  }
}

list_indexes

Listet alle Indizes einer Tabelle auf.

Parameter:

• table (erforderlich): Tabellenname

Beispiel:

{
  "name": "list_indexes",
  "arguments": {
    "table": "accounts"
  }
}

Debug-Modus

Der Server unterstützt optionale Debug-Ausgaben über die Umgebungsvariable MCP_DEBUG. Wenn aktiviert, werden detaillierte Debug-Informationen auf stderr geschrieben (nicht auf stdout, um die MCP-Protokollanforderungen zu erfüllen).

Debug-Modus aktivieren:

{
  "mcpServers": {
    "encrypted-sqlite": {
      "command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
      "args": [
        "--args",
        "{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
      ],
      "env": {
        "MCP_DEBUG": "true"
      }
    }
  }
}

Debug-Ausgabe umfasst:

• Server-Startinformationen (Java-Version, Betriebssystem, Argumente)

• Details zur Konfigurationsanalyse

• Informationen zur Anforderungsverarbeitung

• Antwortgrößen und -strukturen

• Details zur Datenbankverbindung

Hinweis: Die Debug-Ausgabe ist standardmäßig deaktiviert, um die Protokolle sauber zu halten. Aktivieren Sie sie nur bei der Fehlersuche.

Standard-Cipher-Profil

Der Server verwendet standardmäßig SQLCipher 4-Standardeinstellungen:

• cipher_page_size: 4096

• kdf_iter: 256000

• cipher_hmac_algorithm: HMAC_SHA512

• cipher_kdf_algorithm: PBKDF2_HMAC_SHA512

• cipher_use_hmac: ON

• cipher_plaintext_header_size: 0

Diese Einstellungen entsprechen den Standardeinstellungen, die von Tools wie "DB Browser for SQLite" mit SQLCipher 4 verwendet werden.

Entwicklung

Siehe DEVELOPMENT.md für Entwicklungseinrichtung, Build, Tests und Projektstruktur.

Sicherheitsüberlegungen

Allgemeine Sicherheit

• Passphrasen: Passphrasen werden nur im Speicher gehalten und niemals protokolliert

• Verschlüsselte Passphrasen: Verwenden Sie verschlüsselte Passphrasen mit AES-256-GCM, um Passphrasen in Konfigurationsdateien zu speichern (siehe Abschnitt Verschlüsselte Passphrasen)

• Speicher: Beachten Sie, dass entschlüsselte Passphrasen als Java-Strings (unveränderlich) im Speicher verbleiben. Für maximale Sicherheit sollten Sie char[]-Arrays in Betracht ziehen, auch wenn dies derzeit nicht implementiert ist.

• Transport: Verwenden Sie sichere Transportkanäle (z. B. verschlüsselte Sitzungen) beim Fernzugriff auf den Server

• Dateiberechtigungen: Stellen Sie sicher, dass Datenbankdateien über angemessene Dateisystemberechtigungen verfügen

Bewährte Sicherheitspraktiken

1. Verwenden Sie verschlüsselte Passphrasen mit AES-256-GCM-Verschlüsselung

2. Generieren Sie starke Schlüssel mit PassphraseEncryption.generateKey() (256 Bit / 32 Bytes)

3. Speichern Sie Verschlüsselungsschlüssel sicher: Verwenden Sie den macOS-Schlüsselbund (auf macOS empfohlen) oder eine sichere Geheimnisspeicherung

4. Speichern Sie niemals sowohl Verschlüsselungsschlüssel als auch verschlüsselte Passphrase in derselben Konfigurationsdatei – Verwenden Sie Wrapper-Skripte oder Umgebungsvariablen, um den Schlüssel sicher zu laden (siehe DOCKER_CONFIGURATION.md für Details)

5. Rotieren Sie Schlüssel regelmäßig – beim Rotieren alle Passphrasen mit dem neuen Schlüssel erneut verschlüsseln

6. Verwenden Sie unterschiedliche Schlüssel für verschiedene Umgebungen (Entwicklung, Staging, Produktion)

7. Übertragen Sie Schlüssel oder verschlüsselte Passphrasen niemals in die Versionskontrolle

8. Beschränken Sie Dateiberechtigungen für Konfigurationsdateien, die Geheimnisse enthalten (chmod 600)

Fehlerbehebung

Debugging von MCP-Server-Kommunikationsproblemen

Der MCP-Server enthält umfangreiche Debugging-Funktionen, um Kommunikationsprobleme zu diagnostizieren.

Anzeigen von Protokollen

In MCP-Clients:

• Überprüfen Sie die Protokollausgabe Ihres Clients (z. B. Cursor: Ausgabefeld → „MCP-Protokolle")

• Die gesamte Debug-Ausgabe wird nach stderr geschrieben

Manuelles Testen: Ausführen: ./build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite --args '{"db_path":"/path/to/db.sqlite","passphrase":"secret"}' 2>&1 | tee mcp-debug.log

Häufige Kommunikationsprobleme

1. Server startet nicht

• Symptom: Keine Protokolle sichtbar, Server antwortet nicht

• Debugging: Überprüfen Sie die Startprotokolle:

  • Java-Version wird protokolliert

  • Argumente werden protokolliert

  • Konfigurationsanalyse wird protokolliert

• Lösung:

  • Stellen Sie sicher, dass Java korrekt installiert ist

  • Überprüfen Sie die MCP-Konfiguration (mcp.json)

  • Überprüfen Sie die Pfade in den Feldern command und args

2. JSON-Parsing-Fehler

• Symptom: „Parse error" in den Protokollen

• Debugging: Der Server protokolliert:

  • Die ersten 500 Zeichen des empfangenen JSON

  • Die genaue Ausnahme mit Stacktrace

• Lösung:

  • Überprüfen Sie die JSON-Struktur in der MCP-Konfiguration

  • Stellen Sie sicher, dass JSON ordnungsgemäß maskiert ist

  • Stellen Sie sicher, dass alle erforderlichen Felder vorhanden sind

3. Fehlende oder falsche Antworten

• Symptom: Anfragen werden nicht beantwortet oder es treten Zeitüberschreitungen auf

• Debugging: Der Server protokolliert:

  • Jede empfangene Anfrage mit ID und Methode

  • Antwortgröße und Status

  • Flush-Status nach dem Schreiben

• Lösung:

  • Überprüfen Sie, ob STDOUT verfügbar ist (beim Start protokolliert)

  • Überprüfen Sie die Antwortgröße (sehr große Antworten können Probleme verursachen)

  • Stellen Sie sicher, dass der Flush erfolgreich war

4. Ungültige Anfragen

• Symptom: „Invalid Request"-Fehler

• Debugging: Der Server protokolliert:

  • Fehlende Felder (z. B. method, id)

  • JSON-RPC-Versionskonflikte

  • Ungültige Parameter

• Lösung:

  • Stellen Sie sicher, dass alle Anfragen dem JSON-RPC-2.0-Standard entsprechen

  • Überprüfen Sie, ob die Felder method und id vorhanden sind

  • Überprüfen Sie die Parameterstruktur

5. Datenbankverbindungsprobleme

• Symptom: „Database error"-Fehler

• Debugging: Der Server protokolliert:

  • Verwendete DB-Pfade (Standard vs. Überschrieben)

  • Passphrasenstatus (verschlüsselt/entschlüsselt)

  • CipherProfile-Konfiguration

• Lösung:

  • Überprüfen Sie den DB-Pfad in den Protokollen

  • Stellen Sie sicher, dass die Passphrase korrekt entschlüsselt wurde

  • Überprüfen Sie die CipherProfile-Einstellungen

Debugging-Funktionen im Detail

Der Server protokolliert automatisch:

• Startinformationen:

  • Java-Version und Java Home

  • Betriebssysteminformationen

  • Anzahl und Inhalt der Argumente

  • Status der Konfigurationsanalyse

• Anfrageverarbeitung:

  • Jede empfangene Anfrage mit Nummer und Länge

  • JSON-RPC-Validierung

  • Methodenaufrufe mit Parametern

  • Antwortgröße und Status

• Fehlerbehandlung:

  • Detaillierte Ausnahmeinformationen mit Stacktraces

  • JSON-RPC-Fehlercodes gemäß Spezifikation

  • Fehlerantworten mit zusätzlichen Debug-Daten

• Datenbankoperationen:

  • Verwendete Konfigurationen (Standard vs. Überschrieben)

  • SQL-Abfragen (erste 100 Zeichen)

  • Ergebnisgrößen und betroffene Zeilen

Datenbank kann nicht geöffnet werden

• Überprüfen Sie, ob die Passphrase korrekt ist

• Stellen Sie sicher, dass die Datenbank die SQLCipher-4-Standardeinstellungen verwendet (oder konfigurieren Sie ein benutzerdefiniertes Cipher-Profil)

• Stellen Sie sicher, dass der Datenbankdateipfad korrekt und zugänglich ist

• Protokolle prüfen: Der Server protokolliert detaillierte Informationen zur Passphrasenentschlüsselung und zum DB-Pfad

Verbindungsprobleme

• Überprüfen Sie, ob Java installiert ist: java -version

• Stellen Sie sicher, dass JAVA_HOME in der MCP-Konfiguration korrekt gesetzt ist

• Überprüfen Sie die Protokolle Ihres MCP-Clients auf detaillierte Fehlermeldungen

FTS-Tabellen (Volltextsuche)

Der Server behandelt automatisch FTS-virtuelle Tabellen, die möglicherweise keine zugänglichen Metadaten haben. Diese Tabellen erscheinen mit leeren Spaltenlisten.

Lizenz

Lizenziert unter der Apache License, Version 2.0. Siehe LICENSE für Details.

Lizenzen Dritter

• sqlite-jdbc-crypt (Apache License 2.0) – SQLite-JDBC-Treiber mit Verschlüsselungsunterstützung

  • Quelle: https://github.com/Willena/sqlite-jdbc-crypt

• Gson (Apache License 2.0) – JSON-Bibliothek für Java

  • Quelle: https://github.com/google/gson

• JUnit Jupiter (Eclipse Public License 2.0) – Testframework

  • Quelle: https://junit.org/junit5/

Siehe NOTICE für detaillierte Zuschreibungsinformationen.

Danksagungen

• sqlite-jdbc-crypt – SQLite-JDBC-Treiber mit Verschlüsselungsunterstützung

• Model Context Protocol – MCP-Spezifikation

Mitwirken

Beiträge sind willkommen! Sie können gerne einen Pull Request einreichen. Siehe CONTRIBUTING.md für Richtlinien.

Unterstützung

Bei Problemen, Fragen oder Beiträgen öffnen Sie bitte ein Issue auf GitHub.

Kauf mir einen Kaffee

Gefällt Ihnen diese Integration? Kaufen Sie mir gerne einen Kaffee! Ihre Unterstützung hilft mir, weiter an coolen Funktionen zu arbeiten.