pynonymizer-core 1.0.0__py3-none-any.whl

pynonymizer_core-1.0.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: pynonymizer-core
+Version: 1.0.0
+Summary: Native Zero-Dependency In-Memory Database Anonymizer & GDPR Test Data Generator (CLI & MCP Server)
+Author-email: THE HIVE // BSO <diamantenschmiede@proton.me>
+Maintainer: tastenkasperle
+License: MIT
+Project-URL: Homepage, https://github.com/tastenkasperle/pynonymizer_core
+Project-URL: Bug Tracker, https://github.com/tastenkasperle/pynonymizer_core/issues
+Project-URL: Repository, https://github.com/tastenkasperle/pynonymizer_core.git
+Keywords: mcp,mcp-server,database,sqlite,anonymizer,gdpr,dsgvo,test-data,zero-dependency
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🛡️ Pynonymizer Core
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Security: Raptor Guard V2](https://img.shields.io/badge/Security-Raptor_Guard_V2_Zero--Vuln-emerald.svg)](https://github.com/tastenkasperle/pynonymizer_core)
+[![MCP: Stdio Protocol](https://img.shields.io/badge/MCP-JSON--RPC_2.0-orange.svg)](https://modelcontextprotocol.io)
+[![Zero Dependencies](https://img.shields.io/badge/Dependencies-0-brightgreen.svg)](https://github.com/tastenkasperle/pynonymizer_core)
+[![Compliance: GDPR Art. 32](https://img.shields.io/badge/Compliance-GDPR_Art._32-blue.svg)](https://gdpr-info.eu/art-32-gdpr/)
+
+**Pynonymizer Core** is a native, zero-dependency in-memory SQLite database anonymization engine and GDPR/DSGVO test data generator designed for developers, CI/CD pipelines, and autonomous AI agents.
+
+Freed from brittle host dependencies (`pg_dump`, `mysql` in `$PATH`) and heavy ORM overhead, Pynonymizer Core operates directly via Python's native `sqlite3` runtime—either in-memory or on disk with safe copy-on-write isolation.
+
+---
+
+## 🌟 Key Features
+
+- **Zero External Dependencies:** Built purely on Python's standard library. Instant portability across Windows, Linux, and macOS without binary compilation.
+- **Auto Strategy Inference:** Intelligently detects PII columns (names, emails, phone numbers, addresses, salaries, tax IDs) and generates declarative masking strategies.
+- **In-Memory & File-Safe Operations:** Execute high-throughput anonymization entirely in RAM or create verified, scrubbed file copies.
+- **Model Context Protocol (MCP) Ready:** First-class Stdio JSON-RPC 2.0 interface for Claude Desktop, Cursor, Antigravity, and autonomous agent frameworks.
+- **Raptor Guard V2 Certified:** Hardened against SQL injection, column identifier tampering, and path traversal vectors.
+
+---
+
+## 🚀 Quickstart & Installation
+
+Install directly via pip:
+```bash
+pip install .
+```
+
+Or install from distribution:
+```bash
+pip install pynonymizer-core
+```
+
+---
+
+## 💻 CLI Usage
+
+The command-line interface provides lightweight, modular commands for inspection, rule generation, and execution.
+
+### 1. Inspect Database Schema
+Inspect tables, columns, data types, and primary keys:
+```bash
+pynonymizer-core inspect /path/to/database.db
+```
+
+### 2. Auto-Generate Anonymization Strategy
+Infer column semantics and export an editable strategy JSON file:
+```bash
+pynonymizer-core generate-strategy /path/to/database.db > strategy.json
+```
+
+Example `strategy.json`:
+```json
+{
+  "users": {
+    "email": "unique_email",
+    "name": "full_name",
+    "phone": "phone_number"
+  },
+  "employees": {
+    "salary": "random_int"
+  }
+}
+```
+
+### 3. Execute Anonymization
+Anonymize a database file into a sanitized target output:
+```bash
+pynonymizer-core anonymize /path/to/database.db --strategy strategy.json --output /path/to/anonymized.db
+```
+
+---
+
+## 🤖 Model Context Protocol (MCP) Server
+
+Pynonymizer Core includes an embedded Stdio MCP server compliant with JSON-RPC 2.0, giving AI agents direct tools to inspect schemas and sanitize datasets on demand.
+
+### Provided Tools
+
+| Tool Name | Description | Required Arguments |
+|---|---|---|
+| `db_inspect_schema` | Returns tables, columns, types, and primary keys | `db_path` |
+| `db_generate_strategy` | Evaluates schema and generates recommended GDPR masking map | `db_path` |
+| `db_anonymize` | Applies declarative strategy to sanitize database | `source_db`, `strategy` (optional: `target_db`) |
+
+### Claude Desktop / Cursor Setup
+
+Add the following snippet to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "pynonymizer-core": {
+      "command": "python",
+      "args": ["-m", "src.mcp.server"]
+    }
+  }
+}
+```
+
+Or using Docker:
+```json
+{
+  "mcpServers": {
+    "pynonymizer-core": {
+      "command": "docker",
+      "args": ["run", "-i", "--rm", "pynonymizer-core"]
+    }
+  }
+}
+```
+
+---
+
+## 🧪 Testing & Security Verification
+
+Run the test suite:
+```bash
+python -m unittest discover -s tests
+```
+
+### Security Posture (Raptor Guard V2)
+- **Zero Sinks / Leaks:** No outbound socket requests or analytics telemetry.
+- **Prepared Statements:** Parameterized queries for deterministic execution.
+- **Deterministic Tokenization:** Safe synthetic data replacement conforming to GDPR Art. 32 requirements.
+
+---
+
+## 📄 License
+
+MIT License. Developed and maintained by **THE HIVE // BSO** ([diamantenschmiede](https://github.com/tastenkasperle)).

pynonymizer_core-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pynonymizer_core-1.0.0.dist-info/licenses/LICENSE,sha256=wRyj6n6HCtkljZhtP1kSRGxkUlEXVtRXC18SvKypOXo,1097
+src/cli/main.py,sha256=HErZBS9_Anqk-Cksl0hFFQMea4TBP5MWeKfllJQ27zk,1960
+src/core/anonymizer.py,sha256=k4W7dF5TKRKRsmXYHzyiCKn_LR5_CotBcXN2b1UEzVE,7268
+src/core/generators.py,sha256=d4t_2HowntG7TkvuwUlc_e4fb6PcY2khSv7cpQjQ9y0,2830
+src/mcp/server.py,sha256=8eaN5UM2_VMUjBXf5Ep6f1GVYdBI8r46EEkx229xVrw,5984
+pynonymizer_core-1.0.0.dist-info/METADATA,sha256=H6TiiOInVqj_eExX0nQ8NAhExoUZiVz4gkNhMLtaVmk,5618
+pynonymizer_core-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pynonymizer_core-1.0.0.dist-info/entry_points.txt,sha256=W3MfDT9GR9ABsiGnBFXH4rJOg8-t6EY2_wDe-wDnKKs,93
+pynonymizer_core-1.0.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+pynonymizer_core-1.0.0.dist-info/RECORD,,

pynonymizer_core-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pynonymizer_core-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pynonymizer-core = src.cli.main:main
+pynonymizer-mcp = src.mcp.server:main

pynonymizer_core-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 THE HIVE // BSO (Chris & tastenkasperle)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pynonymizer_core-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/cli/main.py

@@ -0,0 +1,56 @@
+"""
+Pynonymizer CLI: Dünner Command-Line-Adapter.
+Anti-Carbonara: Delegiert 100% der Arbeit an src.core.anonymizer.
+"""
+
+import sys
+import json
+import argparse
+from src.core.anonymizer import DatabaseAnonymizer
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Pynonymizer Core - Native SQLite Anonymizer & Test Data Generator")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Command: inspect
+    inspect_parser = subparsers.add_parser("inspect", help="Inspect database schema")
+    inspect_parser.add_argument("db", help="Path to SQLite database")
+
+    # Command: generate-strategy
+    gen_parser = subparsers.add_parser("generate-strategy", help="Auto-generate strategy JSON for database")
+    gen_parser.add_argument("db", help="Path to SQLite database")
+
+    # Command: anonymize
+    anon_parser = subparsers.add_parser("anonymize", help="Anonymize SQLite database")
+    anon_parser.add_argument("db", help="Source SQLite database")
+    anon_parser.add_argument("--strategy", required=True, help="Path to strategy JSON file")
+    anon_parser.add_argument("--output", help="Optional output database file (safe copy)", default=None)
+
+    args = parser.parse_args()
+
+    if args.command == "inspect":
+        anon = DatabaseAnonymizer(args.db)
+        schema = anon.inspect_schema()
+        print(json.dumps(schema, indent=2))
+        return 0
+
+    elif args.command == "generate-strategy":
+        anon = DatabaseAnonymizer(args.db)
+        strategy = anon.generate_strategy()
+        print(json.dumps(strategy, indent=2))
+        return 0
+
+    elif args.command == "anonymize":
+        with open(args.strategy, "r", encoding="utf-8") as f:
+            strategy = json.load(f)
+        anon = DatabaseAnonymizer(args.db)
+        res = anon.anonymize(strategy, target_path=args.output)
+        print(json.dumps(res, indent=2))
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/core/anonymizer.py

@@ -0,0 +1,171 @@
+"""
+Pynonymizer Core: Native SQLite Anonymizer & Schema Inspector.
+Executes in-place or file-to-file database anonymization using declarative rules.
+Anti-Carbonara: Pure Logic, No CLI.
+"""
+
+import sqlite3
+import os
+import shutil
+from typing import Dict, Any, List, Optional, Tuple
+from src.core.generators import FakeDataGenerator
+
+
+class DatabaseAnonymizer:
+    def __init__(self, db_path: str):
+        self.db_path = self._validate_db_path(db_path)
+
+    @staticmethod
+    def _validate_db_path(path_str: str) -> str:
+        if not path_str or not isinstance(path_str, str):
+            raise ValueError("Invalid database path provided")
+        if "\x00" in path_str:
+            raise ValueError("Security Violation: Null byte in database path")
+        base = os.path.basename(os.path.abspath(path_str)).lower()
+        if base.startswith(".env") or base.startswith("id_rsa") or base.startswith("id_ed25519") or "masterpw" in base:
+            raise ValueError(f"Security Violation: Protected credential file blocked: {base}")
+        return path_str
+
+    @staticmethod
+    def _quote_ident(ident: str) -> str:
+        if not isinstance(ident, str) or "\x00" in ident:
+            raise ValueError("Invalid SQL identifier")
+        return '"' + ident.replace('"', '""') + '"'
+
+    def inspect_schema(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Returns tables and their columns with types."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        schema: Dict[str, List[Dict[str, Any]]] = {}
+
+        try:
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';")
+            tables = [row[0] for row in cursor.fetchall()]
+
+            for t in tables:
+                cursor.execute(f"PRAGMA table_info({self._quote_ident(t)});")
+                cols = cursor.fetchall()
+                schema[t] = [
+                    {"cid": c[0], "name": c[1], "type": c[2], "notnull": bool(c[3]), "pk": bool(c[5])}
+                    for c in cols
+                ]
+        finally:
+            conn.close()
+
+        return schema
+
+    def generate_strategy(self) -> Dict[str, Dict[str, str]]:
+        """Automatically infers a strategy map based on column names."""
+        schema = self.inspect_schema()
+        strategy: Dict[str, Dict[str, str]] = {}
+
+        for table, cols in schema.items():
+            table_rules: Dict[str, str] = {}
+            for col in cols:
+                cname = col["name"].lower()
+                if "email" in cname or "mail" in cname:
+                    table_rules[col["name"]] = "email"
+                elif "phone" in cname or "tel" in cname or "mobile" in cname:
+                    table_rules[col["name"]] = "phone"
+                elif "first_name" in cname or "firstname" in cname or "vorname" in cname:
+                    table_rules[col["name"]] = "first_name"
+                elif "last_name" in cname or "lastname" in cname or "nachname" in cname:
+                    table_rules[col["name"]] = "last_name"
+                elif "name" in cname and not col["pk"]:
+                    table_rules[col["name"]] = "full_name"
+                elif "company" in cname or "firma" in cname or "arbeitgeber" in cname:
+                    table_rules[col["name"]] = "company"
+                elif "iban" in cname or "konto" in cname:
+                    table_rules[col["name"]] = "iban"
+
+            if table_rules:
+                strategy[table] = table_rules
+
+        return strategy
+
+    def anonymize(self, strategy: Dict[str, Dict[str, str]], target_path: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Applies strategy to anonymize database.
+        If target_path is specified, creates a safe copy first and anonymizes the copy.
+        """
+        work_path = self.db_path
+        if target_path:
+            target_path = self._validate_db_path(target_path)
+            shutil.copyfile(self.db_path, target_path)
+            work_path = target_path
+
+        conn = sqlite3.connect(work_path)
+        cursor = conn.cursor()
+        stats: Dict[str, int] = {}
+        total_rows_modified = 0
+
+        try:
+            for table, rules in strategy.items():
+                if not isinstance(rules, dict) or not rules:
+                    continue
+                # Verify table exists
+                cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table,))
+                if not cursor.fetchone():
+                    continue
+
+                quoted_table = self._quote_ident(table)
+
+                # Find primary key or rowid for row identification
+                cursor.execute(f"PRAGMA table_info({quoted_table});")
+                cols_info = cursor.fetchall()
+                col_names = [c[1] for c in cols_info]
+                pk_cols = [c[1] for c in cols_info if c[5] > 0]
+                id_col = pk_cols[0] if pk_cols else "rowid"
+                quoted_id_col = self._quote_ident(id_col)
+
+                # Validate all strategy columns against actual schema columns to prevent SQL injection
+                for col_name in rules.keys():
+                    if col_name not in col_names:
+                        raise ValueError(f"Security Violation: Column '{col_name}' does not exist in table '{table}'")
+
+                # Safely construct queries with validated & quoted identifiers
+                cols_to_fetch = [id_col] + list(rules.keys())
+                select_sql = "SELECT " + ", ".join(self._quote_ident(c) for c in cols_to_fetch) + f" FROM {quoted_table}"
+                cursor.execute(select_sql)
+                rows = cursor.fetchall()
+
+                table_modified = 0
+                for row in rows:
+                    row_id = row[0]
+                    update_parts = []
+                    params = []
+
+                    for idx, (col_name, rule_type) in enumerate(rules.items(), start=1):
+                        current_val = row[idx]
+                        if current_val is None:
+                            continue
+                        generator = FakeDataGenerator.get_generator(rule_type)
+                        try:
+                            # Pass current value if mask/hash
+                            fake_val = generator(current_val) if rule_type in ["mask", "hash"] else generator()
+                        except Exception:
+                            fake_val = generator()
+
+                        update_parts.append(f"{self._quote_ident(col_name)} = ?")
+                        params.append(fake_val)
+
+                    if update_parts:
+                        params.append(row_id)
+                        update_sql = f"UPDATE {quoted_table} SET " + ", ".join(update_parts) + f" WHERE {quoted_id_col} = ?"
+                        cursor.execute(update_sql, params)
+                        table_modified += 1
+
+                stats[table] = table_modified
+                total_rows_modified += table_modified
+
+            conn.commit()
+        finally:
+            conn.close()
+
+        return {
+            "status": "success",
+            "database_file": work_path,
+            "tables_affected": len(stats),
+            "rows_anonymized": total_rows_modified,
+            "breakdown": stats
+        }

src/core/generators.py

@@ -0,0 +1,79 @@
+"""
+Pynonymizer Core: Generators & Strategy Engine.
+Pure Python, Zero External Dependencies, 100% In-Memory.
+Anti-Carbonara: Pure Logic, No CLI, No print(), No sys.exit().
+"""
+
+import hashlib
+import random
+import re
+from typing import Dict, Any, List, Callable, Optional
+
+
+class FakeDataGenerator:
+    """Lightweight, deterministic and random fake data generators without bloated dependencies."""
+
+    FIRST_NAMES = ["Alex", "Chris", "Jordan", "Taylor", "Sam", "Morgan", "Robin", "Casey", "Kim", "Pat", "Felix", "Laura", "Max", "Sophie", "Lukas", "Elena"]
+    LAST_NAMES = ["Mueller", "Schmidt", "Schneider", "Fischer", "Weber", "Meyer", "Wagner", "Becker", "Schulz", "Hoffmann", "Koch", "Bauer", "Richter"]
+    COMPANIES = ["Nexus Tech", "Alpha Innovations", "Sol Solutions", "Vanguard Media", "Peak Systems", "Aurora Digital", "Titan Industries"]
+    DOMAINS = ["example.com", "testmail.org", "internal.local", "dummycorp.net"]
+
+    @classmethod
+    def first_name(cls) -> str:
+        return random.choice(cls.FIRST_NAMES)
+
+    @classmethod
+    def last_name(cls) -> str:
+        return random.choice(cls.LAST_NAMES)
+
+    @classmethod
+    def full_name(cls) -> str:
+        return f"{cls.first_name()} {cls.last_name()}"
+
+    @classmethod
+    def email(cls, prefix: Optional[str] = None) -> str:
+        name = prefix or f"{cls.first_name().lower()}.{cls.last_name().lower()}"
+        clean_name = re.sub(r'[^a-zA-Z0-9._]', '', name)
+        num = random.randint(100, 9999)
+        domain = random.choice(cls.DOMAINS)
+        return f"{clean_name}_{num}@{domain}"
+
+    @classmethod
+    def phone(cls) -> str:
+        return f"+49 {random.randint(150, 179)} {random.randint(1000000, 9999999)}"
+
+    @classmethod
+    def company(cls) -> str:
+        return random.choice(cls.COMPANIES)
+
+    @classmethod
+    def iban(cls) -> str:
+        account_num = f"{random.randint(1000000000, 9999999999)}"
+        return f"DE{random.randint(10, 99)}50010517{account_num}"
+
+    @classmethod
+    def mask_string(cls, val: Any) -> str:
+        s = str(val)
+        if len(s) <= 2:
+            return "**"
+        return s[0] + "*" * (len(s) - 2) + s[-1]
+
+    @classmethod
+    def hash_value(cls, val: Any) -> str:
+        return hashlib.sha256(str(val).encode("utf-8")).hexdigest()[:16]
+
+    @classmethod
+    def get_generator(cls, rule_type: str) -> Callable[..., Any]:
+        mapping = {
+            "first_name": cls.first_name,
+            "last_name": cls.last_name,
+            "full_name": cls.full_name,
+            "email": cls.email,
+            "unique_email": cls.email,
+            "phone": cls.phone,
+            "company": cls.company,
+            "iban": cls.iban,
+            "mask": cls.mask_string,
+            "hash": cls.hash_value,
+        }
+        return mapping.get(rule_type.lower(), lambda val=None: "ANONYMIZED")

src/mcp/server.py

@@ -0,0 +1,159 @@
+"""
+Pynonymizer MCP Server: Stdio-basierter JSON-RPC 2.0 Server.
+Ermöglicht autonomen KI-Agenten die automatische Testdaten-Generierung und Anonymisierung.
+Anti-Carbonara Standard: Pure Core Integration.
+"""
+
+import sys
+import json
+import logging
+from src.core.anonymizer import DatabaseAnonymizer
+
+logging.basicConfig(level=logging.INFO, stream=sys.stderr, format="%(asctime)s [%(levelname)s] %(message)s")
+
+
+class PynonymizerMCPServer:
+    def __init__(self):
+        self.tools = [
+            {
+                "name": "db_inspect_schema",
+                "description": "Inspects tables, columns, data types, and primary keys of a SQLite database.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "db_path": {"type": "string", "description": "Absolute path to SQLite database file"}
+                    },
+                    "required": ["db_path"]
+                }
+            },
+            {
+                "name": "db_generate_strategy",
+                "description": "Analyzes column names in a database and generates an automatic GDPR/DSGVO masking strategy.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "db_path": {"type": "string", "description": "Absolute path to SQLite database file"}
+                    },
+                    "required": ["db_path"]
+                }
+            },
+            {
+                "name": "db_anonymize",
+                "description": "Applies a masking strategy to anonymize sensitive columns in a SQLite database (creates safe copy if target_path given).",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "source_db": {"type": "string", "description": "Path to source SQLite database"},
+                        "strategy": {"type": "object", "description": "Strategy map: {tableName: {columnName: ruleType}}"},
+                        "target_db": {"type": "string", "description": "Optional path for safe anonymized copy"}
+                    },
+                    "required": ["source_db", "strategy"]
+                }
+            }
+        ]
+
+    def handle_request(self, req: dict) -> dict:
+        req_id = req.get("id")
+        method = req.get("method")
+        params = req.get("params", {})
+
+        if method == "initialize":
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "pynonymizer-core", "version": "1.0.0"}
+                }
+            }
+
+        elif method in ("notifications/initialized", "initialized") or (isinstance(method, str) and method.startswith("notifications/")) or req_id is None:
+            return None
+
+        elif method == "ping":
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {}
+            }
+
+        elif method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {"tools": self.tools}
+            }
+
+        elif method == "tools/call":
+            tool_name = params.get("name")
+            args = params.get("arguments", {})
+
+            try:
+                if tool_name == "db_inspect_schema":
+                    anon = DatabaseAnonymizer(args.get("db_path"))
+                    schema = anon.inspect_schema()
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": req_id,
+                        "result": {"content": [{"type": "text", "text": json.dumps(schema, indent=2)}]}
+                    }
+
+                elif tool_name == "db_generate_strategy":
+                    anon = DatabaseAnonymizer(args.get("db_path"))
+                    strat = anon.generate_strategy()
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": req_id,
+                        "result": {"content": [{"type": "text", "text": json.dumps(strat, indent=2)}]}
+                    }
+
+                elif tool_name == "db_anonymize":
+                    anon = DatabaseAnonymizer(args.get("source_db"))
+                    res = anon.anonymize(args.get("strategy"), target_path=args.get("target_db"))
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": req_id,
+                        "result": {"content": [{"type": "text", "text": json.dumps(res, indent=2)}]}
+                    }
+
+                else:
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": req_id,
+                        "error": {"code": -32601, "message": f"Method {tool_name} not found"}
+                    }
+
+            except Exception as e:
+                logging.exception(f"Error executing tool {tool_name}")
+                return {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32000, "message": str(e)}
+                }
+
+        return {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "error": {"code": -32600, "message": "Invalid Request"}
+        }
+
+    def run(self):
+        logging.info("Pynonymizer MCP Server running on stdio.")
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                req = json.loads(line)
+                resp = self.handle_request(req)
+                if resp is not None:
+                    sys.stdout.write(json.dumps(resp) + "\n")
+                    sys.stdout.flush()
+            except Exception:
+                pass
+
+
+if __name__ == "__main__":
+    server = PynonymizerMCPServer()
+    server.run()