cks-mcp 0.1.1__tar.gz

cks_mcp-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deus-corp
+
+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.

cks_mcp-0.1.1/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: cks-mcp
+Version: 0.1.1
+Summary: CKS MCP Server — Canonical Knowledge Structure for LLMs
+Author: Vladyslav Hruznov
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cks-core>=1.1.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Dynamic: license-file
+
+# CKS MCP Server
+
+> Model Context Protocol server for Canonical Knowledge Structure.
+
+![Python](https://img.shields.io/badge/python-3.12%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-20%20passing-brightgreen)
+
+`cks-mcp` is an MCP (Model Context Protocol) server that provides LLMs
+with structured, verifiable knowledge operations through the CKS
+ecosystem.  It exposes six tools—validate, query, compare, evolve,
+derive, and construct—each backed by the deterministic, immutable
+semantics of `cks-core`.
+
+---
+
+# Why cks-mcp?
+
+LLMs generate plausible but unverified statements.  `cks-mcp` gives them
+a **canonical knowledge backbone**: every piece of information must be
+explicitly structured, validated against formal constraints, and
+traceable to its origin.  This minimises hallucinations and makes AI‑
+generated knowledge auditable.
+
+---
+
+# Installation
+
+```bash
+pip install cks-mcp
+```
+
+The server requires `cks-core` (installed automatically as a dependency).
+
+---
+
+# Quick Start
+
+Launch the server:
+
+```bash
+cks-mcp
+```
+
+An MCP client (Claude Desktop, any MCP-compatible LLM) can then connect
+and call tools.
+
+---
+
+# Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `validate_knowledge` | Validate a Knowledge Structure and return diagnostics. |
+| `query_relations`   | Find all relations for a given entity. |
+| `compare_structures`| Check semantic equivalence of two structures. |
+| `evolve_knowledge`  | Apply Genesis/Decay operators to evolve a structure. |
+| `derive_knowledge`  | Derive a new Knowledge Object from existing premises. |
+| `construct_knowledge`| Parse and construct a Knowledge Structure (coming soon). |
+
+---
+
+# Usage Example
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "tools/call",
+  "params": {
+    "name": "validate_knowledge",
+    "arguments": {
+      "json_data": "{\"objects\":[{\"identity\":{\"id\":\"obj-1\",\"type\":\"Definition\",\"name\":\"Test\"},\"structure\":{}}]}"
+    }
+  }
+}
+```
+
+Response:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": "{\"valid\": true, \"error_count\": 0, \"warning_count\": 0, \"diagnostics\": []}"
+}
+```
+
+---
+
+# Testing
+
+```bash
+python -m pytest -v
+```
+
+20 tests, all passing.
+
+---
+
+# Ecosystem
+
+- **cks-core** — the canonical knowledge engine ([repo](https://github.com/Deus-corp/CKS))
+- **CKS Specifications** — formal theory behind the system ([DOI](https://zenodo.org/records/21332624))
+
+---
+
+# License
+
+MIT

cks_mcp-0.1.1/README.md

@@ -0,0 +1,110 @@
+# CKS MCP Server
+
+> Model Context Protocol server for Canonical Knowledge Structure.
+
+![Python](https://img.shields.io/badge/python-3.12%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-20%20passing-brightgreen)
+
+`cks-mcp` is an MCP (Model Context Protocol) server that provides LLMs
+with structured, verifiable knowledge operations through the CKS
+ecosystem.  It exposes six tools—validate, query, compare, evolve,
+derive, and construct—each backed by the deterministic, immutable
+semantics of `cks-core`.
+
+---
+
+# Why cks-mcp?
+
+LLMs generate plausible but unverified statements.  `cks-mcp` gives them
+a **canonical knowledge backbone**: every piece of information must be
+explicitly structured, validated against formal constraints, and
+traceable to its origin.  This minimises hallucinations and makes AI‑
+generated knowledge auditable.
+
+---
+
+# Installation
+
+```bash
+pip install cks-mcp
+```
+
+The server requires `cks-core` (installed automatically as a dependency).
+
+---
+
+# Quick Start
+
+Launch the server:
+
+```bash
+cks-mcp
+```
+
+An MCP client (Claude Desktop, any MCP-compatible LLM) can then connect
+and call tools.
+
+---
+
+# Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `validate_knowledge` | Validate a Knowledge Structure and return diagnostics. |
+| `query_relations`   | Find all relations for a given entity. |
+| `compare_structures`| Check semantic equivalence of two structures. |
+| `evolve_knowledge`  | Apply Genesis/Decay operators to evolve a structure. |
+| `derive_knowledge`  | Derive a new Knowledge Object from existing premises. |
+| `construct_knowledge`| Parse and construct a Knowledge Structure (coming soon). |
+
+---
+
+# Usage Example
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "tools/call",
+  "params": {
+    "name": "validate_knowledge",
+    "arguments": {
+      "json_data": "{\"objects\":[{\"identity\":{\"id\":\"obj-1\",\"type\":\"Definition\",\"name\":\"Test\"},\"structure\":{}}]}"
+    }
+  }
+}
+```
+
+Response:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": "{\"valid\": true, \"error_count\": 0, \"warning_count\": 0, \"diagnostics\": []}"
+}
+```
+
+---
+
+# Testing
+
+```bash
+python -m pytest -v
+```
+
+20 tests, all passing.
+
+---
+
+# Ecosystem
+
+- **cks-core** — the canonical knowledge engine ([repo](https://github.com/Deus-corp/CKS))
+- **CKS Specifications** — formal theory behind the system ([DOI](https://zenodo.org/records/21332624))
+
+---
+
+# License
+
+MIT

cks_mcp-0.1.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=77.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cks-mcp"
+version = "0.1.1"
+description = "CKS MCP Server — Canonical Knowledge Structure for LLMs"
+readme = "README.md"
+authors = [{name = "Vladyslav Hruznov"}]
+license = {text = "MIT"}
+requires-python = ">=3.12"
+dependencies = [
+    "cks-core>=1.1.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+cks-mcp = "cks_mcp.server:main"

cks_mcp-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cks_mcp-0.1.1/src/cks_mcp/server.py

@@ -0,0 +1,212 @@
+"""
+CKS MCP Server — JSON-RPC over stdio.
+
+Implements the Model Context Protocol (MCP) to expose CKS tools
+to LLM clients.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Any, Callable, Dict, Optional
+
+from .tools.validate import validate_knowledge
+from .tools.query import query_relations
+from .tools.compare import compare_structures
+from .tools.evolve import evolve_knowledge
+from .tools.derive import derive_knowledge
+
+
+# Registry of available tools
+TOOLS: Dict[str, Dict[str, Any]] = {
+    "validate_knowledge": {
+        "name": "validate_knowledge",
+        "description": "Validate a canonical knowledge structure and return diagnostics.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "json_data": {
+                    "type": "string",
+                    "description": "A JSON string representing a Knowledge Structure.",
+                },
+            },
+            "required": ["json_data"],
+        },
+    },
+    "query_relations": {
+        "name": "query_relations",
+        "description": "Query all relations for a given entity.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "json_data": {
+                    "type": "string",
+                    "description": "A JSON string representing a Knowledge Structure.",
+                },
+                "entity_id": {
+                    "type": "string",
+                    "description": "The canonical identity of the entity to query.",
+                },
+            },
+            "required": ["json_data", "entity_id"],
+        },
+    },
+    "compare_structures": {
+        "name": "compare_structures",
+        "description": "Compare two knowledge structures for semantic equivalence.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "json_data_a": {
+                    "type": "string",
+                    "description": "A JSON string representing the first Knowledge Structure.",
+                },
+                "json_data_b": {
+                    "type": "string",
+                    "description": "A JSON string representing the second Knowledge Structure.",
+                },
+            },
+            "required": ["json_data_a", "json_data_b"],
+        },
+    },
+    "evolve_knowledge": {
+        "name": "evolve_knowledge",
+        "description": "Apply a sequence of structural operators to a knowledge structure.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "json_data": {
+                    "type": "string",
+                    "description": "A JSON string representing a Knowledge Structure.",
+                },
+                "operations": {
+                    "type": "string",
+                    "description": "A JSON string with an array of operation objects.",
+                },
+            },
+            "required": ["json_data", "operations"],
+        },
+    },
+    "derive_knowledge": {
+        "name": "derive_knowledge",
+        "description": "Derive a new Knowledge Object from existing premises.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "json_data": {
+                    "type": "string",
+                    "description": "A JSON string representing a Knowledge Structure.",
+                },
+                "premises": {
+                    "type": "string",
+                    "description": "A JSON array of canonical identities used as premises.",
+                },
+                "rule": {
+                    "type": "string",
+                    "description": "The canonical inference rule identifier.",
+                },
+                "conclusion_id": {
+                    "type": "string",
+                    "description": "Canonical identity for the new Knowledge Object.",
+                },
+                "conclusion_type": {
+                    "type": "string",
+                    "description": "Canonical type for the new Knowledge Object.",
+                },
+                "conclusion_name": {
+                    "type": "string",
+                    "description": "Human-readable name for the new Knowledge Object.",
+                },
+            },
+            "required": ["json_data", "premises", "rule", "conclusion_id", "conclusion_type", "conclusion_name"],
+        },
+    },
+}
+
+# Mapping from tool name to callable
+HANDLERS: Dict[str, Callable[..., str]] = {
+    "validate_knowledge": validate_knowledge,
+    "query_relations": query_relations,
+    "compare_structures": compare_structures,
+    "evolve_knowledge": evolve_knowledge,
+    "derive_knowledge": derive_knowledge,
+}
+
+
+async def handle_request(request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Handle a single JSON-RPC request and return a response."""
+    method = request.get("method")
+    params = request.get("params", {})
+    req_id = request.get("id")
+
+    if method == "tools/list":
+        return {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "result": list(TOOLS.values()),
+        }
+    elif method == "tools/call":
+        tool_name = params.get("name")
+        tool_args = params.get("arguments", {})
+        handler = HANDLERS.get(tool_name)
+        if handler is None:
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "error": {"code": -32601, "message": f"Tool '{tool_name}' not found"},
+            }
+        try:
+            result = handler(**tool_args)
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": result,
+            }
+        except Exception as exc:
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "error": {"code": -32000, "message": str(exc)},
+            }
+
+    return {
+        "jsonrpc": "2.0",
+        "id": req_id,
+        "error": {"code": -32601, "message": f"Method '{method}' not found"},
+    }
+
+
+async def main_loop() -> None:
+    """Read JSON-RPC requests from stdin and write responses to stdout."""
+    reader = asyncio.StreamReader()
+    await asyncio.get_event_loop().connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader),
+        sys.stdin,
+    )
+
+    writer = asyncio.StreamWriter(sys.stdout.buffer, None, None, None)
+
+    while True:
+        line = await reader.readline()
+        if not line:
+            break
+        try:
+            request = json.loads(line.decode("utf-8"))
+        except json.JSONDecodeError:
+            continue
+
+        response = await handle_request(request)
+        if response is not None:
+            writer.write(json.dumps(response).encode("utf-8") + b"\n")
+            await writer.drain()
+
+
+def main() -> None:
+    """Entry point for the MCP server."""
+    asyncio.run(main_loop())
+
+
+if __name__ == "__main__":
+    main()

cks_mcp-0.1.1/src/cks_mcp/tools/compare.py

@@ -0,0 +1,51 @@
+"""
+MCP Tool: compare_structures.
+
+Compares two knowledge structures for semantic equivalence.
+"""
+
+import json
+from typing import Any, Dict
+
+from cks.serialization import parse as cks_parse, SerializationError
+from cks.core import KnowledgeStructure
+
+
+def compare_structures(json_data_a: str, json_data_b: str) -> str:
+    """
+    Compare two knowledge structures for semantic equivalence.
+
+    Args:
+        json_data_a: A JSON string representing the first Knowledge Structure.
+        json_data_b: A JSON string representing the second Knowledge Structure.
+
+    Returns:
+        A JSON string with equivalence result and details.
+    """
+    try:
+        data_a = json.loads(json_data_a) if isinstance(json_data_a, str) else json_data_a
+        structure_a = cks_parse(data_a)
+    except (json.JSONDecodeError, SerializationError) as exc:
+        return json.dumps({
+            "error": f"Failed to parse first structure: {exc}",
+            "equivalent": False,
+        })
+
+    try:
+        data_b = json.loads(json_data_b) if isinstance(json_data_b, str) else json_data_b
+        structure_b = cks_parse(data_b)
+    except (json.JSONDecodeError, SerializationError) as exc:
+        return json.dumps({
+            "error": f"Failed to parse second structure: {exc}",
+            "equivalent": False,
+        })
+
+    is_equivalent = structure_a.structurally_equivalent(structure_b)
+
+    return json.dumps({
+        "equivalent": is_equivalent,
+        "objects_a": len(structure_a.objects),
+        "objects_b": len(structure_b.objects),
+        "relations_a": len(structure_a.relations()),
+        "relations_b": len(structure_b.relations()),
+    })

cks_mcp-0.1.1/src/cks_mcp/tools/derive.py

@@ -0,0 +1,58 @@
+"""
+MCP Tool: derive_knowledge.
+
+Creates a new Knowledge Object derived from existing ones via a canonical derivation.
+"""
+
+import json
+from typing import Any, Dict, List
+
+from cks.serialization import parse as cks_parse, SerializationError
+from cks.core import KnowledgeObject, ObjectIdentity
+
+
+def derive_knowledge(json_data: str, premises: str, rule: str, conclusion_id: str, conclusion_type: str, conclusion_name: str) -> str:
+    """
+    Derive a new Knowledge Object from existing premises.
+
+    Args:
+        json_data: A JSON string representing a Knowledge Structure.
+        premises: A JSON array of canonical identities used as premises.
+        rule: The canonical inference rule identifier.
+        conclusion_id: Canonical identity for the new Knowledge Object.
+        conclusion_type: Canonical type for the new Knowledge Object.
+        conclusion_name: Human-readable name for the new Knowledge Object.
+
+    Returns:
+        A JSON string with the updated Knowledge Structure containing the derivation.
+    """
+    try:
+        data = json.loads(json_data) if isinstance(json_data, str) else json_data
+        structure = cks_parse(data)
+    except (json.JSONDecodeError, SerializationError) as exc:
+        return json.dumps({"error": f"Failed to parse input: {exc}"})
+
+    premise_ids = json.loads(premises) if isinstance(premises, str) else premises
+    for pid in premise_ids:
+        if structure.get(pid) is None:
+            return json.dumps({"error": f"Premise '{pid}' not found in structure"})
+
+    if structure.get(conclusion_id) is not None:
+        return json.dumps({"error": f"Conclusion '{conclusion_id}' already exists in structure"})
+
+    conclusion = KnowledgeObject(
+        identity=ObjectIdentity(id=conclusion_id, type=conclusion_type, name=conclusion_name),
+        structure={
+            "derived_from": premise_ids,
+            "rule": rule,
+        },
+    )
+
+    # Build a new structure with the conclusion added
+    objects = list(structure.objects)
+    objects.append(conclusion)
+    from cks.core import KnowledgeStructure
+    new_structure = KnowledgeStructure(objects)
+
+    from cks.serialization import serialize as cks_serialize
+    return cks_serialize(new_structure)

cks_mcp-0.1.1/src/cks_mcp/tools/evolve.py

@@ -0,0 +1,92 @@
+"""
+MCP Tool: evolve_knowledge.
+
+Applies a sequence of structural operators to a knowledge structure.
+"""
+
+import json
+from typing import Any, Dict, List
+
+from cks.serialization import parse as cks_parse, SerializationError
+from cks.evolution import compose, AddObject, AddRelation, RemoveObject, RemoveRelation
+from cks.core import KnowledgeObject, CanonicalRelation, ObjectIdentity
+
+
+def _parse_operations(ops_data: List[Dict[str, Any]]) -> List[Any]:
+    """Parse a list of operation dictionaries into structural operators."""
+    operators = []
+    for i, op in enumerate(ops_data):
+        op_type = op.get("type")
+        if op_type is None:
+            raise ValueError(f"Operation #{i}: missing 'type' field")
+        if op_type == "add_object":
+            identity_data = op.get("identity")
+            if identity_data is None:
+                raise ValueError(f"Operation #{i}: missing 'identity' field")
+            identity = ObjectIdentity(**identity_data)
+            obj = KnowledgeObject(identity=identity, structure=op.get("structure", {}))
+            operators.append(AddObject(obj))
+        elif op_type == "add_relation":
+            identity_data = op.get("identity")
+            if identity_data is None:
+                raise ValueError(f"Operation #{i}: missing 'identity' field")
+            identity = ObjectIdentity(**identity_data)
+            participants = op.get("participants")
+            if participants is None:
+                raise ValueError(f"Operation #{i}: missing 'participants' field")
+            relation_type = op.get("relation_type")
+            if relation_type is None:
+                raise ValueError(f"Operation #{i}: missing 'relation_type' field")
+            relation = CanonicalRelation(
+                identity=identity,
+                participants=participants,
+                relation_type=relation_type,
+                structure=op.get("structure", {}),
+            )
+            operators.append(AddRelation(relation))
+        elif op_type == "remove_object":
+            object_id = op.get("object_id")
+            if object_id is None:
+                raise ValueError(f"Operation #{i}: missing 'object_id' field")
+            operators.append(RemoveObject(object_id))
+        elif op_type == "remove_relation":
+            relation_id = op.get("relation_id")
+            if relation_id is None:
+                raise ValueError(f"Operation #{i}: missing 'relation_id' field")
+            operators.append(RemoveRelation(relation_id))
+        else:
+            raise ValueError(f"Operation #{i}: unknown operation type '{op_type}'")
+    return operators
+
+
+def evolve_knowledge(json_data: str, operations: str) -> str:
+    """
+    Apply a sequence of structural operators to a knowledge structure.
+
+    Args:
+        json_data: A JSON string representing a Knowledge Structure.
+        operations: A JSON string with an array of operation objects.
+
+    Returns:
+        A JSON string with the evolved Knowledge Structure.
+    """
+    try:
+        data = json.loads(json_data) if isinstance(json_data, str) else json_data
+        structure = cks_parse(data)
+    except (json.JSONDecodeError, SerializationError) as exc:
+        return json.dumps({"error": f"Failed to parse input: {exc}"})
+
+    try:
+        ops_data = json.loads(operations) if isinstance(operations, str) else operations
+        operators = _parse_operations(ops_data)
+    except (json.JSONDecodeError, ValueError) as exc:
+        return json.dumps({"error": f"Failed to parse operations: {exc}"})
+
+    try:
+        evolved = compose(structure, operators)
+    except Exception as exc:
+        return json.dumps({"error": f"Evolution failed: {exc}"})
+
+    # Serialize back to JSON
+    from cks.serialization import serialize as cks_serialize
+    return cks_serialize(evolved)

cks_mcp-0.1.1/src/cks_mcp/tools/query.py

@@ -0,0 +1,45 @@
+"""
+MCP Tool: query_relations.
+
+Returns all canonical relations for a given entity.
+"""
+
+import json
+from typing import Any, Dict, List
+
+from cks.serialization import parse as cks_parse, SerializationError
+
+
+def query_relations(json_data: str, entity_id: str) -> str:
+    """
+    Query all relations for a given entity in a knowledge structure.
+
+    Args:
+        json_data: A JSON string representing a Knowledge Structure.
+        entity_id: The canonical identity of the entity to query.
+
+    Returns:
+        A JSON string with the list of relations involving the entity.
+    """
+    try:
+        data = json.loads(json_data) if isinstance(json_data, str) else json_data
+        structure = cks_parse(data)
+    except (json.JSONDecodeError, SerializationError) as exc:
+        return json.dumps({
+            "error": f"Failed to parse input: {exc}",
+            "relations": [],
+        })
+
+    relations: List[Dict[str, Any]] = []
+    for rel in structure.relations():
+        if entity_id in rel.participants:
+            relations.append({
+                "relation_id": rel.identity.id,
+                "relation_type": rel.relation_type,
+                "participants": list(rel.participants),
+            })
+
+    return json.dumps({
+        "entity_id": entity_id,
+        "relations": relations,
+    })

cks_mcp-0.1.1/src/cks_mcp/tools/validate.py

@@ -0,0 +1,51 @@
+"""
+MCP Tool: validate_knowledge.
+
+Validates a canonical knowledge structure and returns diagnostics.
+"""
+
+import json
+from typing import Any, Dict
+
+from cks.serialization import parse as cks_parse, SerializationError
+from cks.validator import validate as cks_validate
+from cks.diagnostics import DiagnosticSeverity
+
+
+def validate_knowledge(json_data: str) -> str:
+    """
+    Validate a knowledge structure in canonical JSON format.
+
+    Args:
+        json_data: A JSON string representing a Knowledge Structure.
+
+    Returns:
+        A JSON string with validation result and diagnostics.
+    """
+    try:
+        data = json.loads(json_data) if isinstance(json_data, str) else json_data
+        structure = cks_parse(data)
+    except (json.JSONDecodeError, SerializationError) as exc:
+        return json.dumps({
+            "valid": False,
+            "error": f"Failed to parse input: {exc}",
+            "diagnostics": [],
+        })
+
+    result = cks_validate(structure)
+
+    diagnostics = []
+    for diag in result.diagnostics:
+        diagnostics.append({
+            "identity": diag.identity,
+            "severity": diag.severity.value,
+            "message": diag.message,
+            "location": diag.location,
+        })
+
+    return json.dumps({
+        "valid": result.is_valid,
+        "error_count": result.error_count,
+        "warning_count": result.warning_count,
+        "diagnostics": diagnostics,
+    })

cks_mcp-0.1.1/src/cks_mcp.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: cks-mcp
+Version: 0.1.1
+Summary: CKS MCP Server — Canonical Knowledge Structure for LLMs
+Author: Vladyslav Hruznov
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cks-core>=1.1.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Dynamic: license-file
+
+# CKS MCP Server
+
+> Model Context Protocol server for Canonical Knowledge Structure.
+
+![Python](https://img.shields.io/badge/python-3.12%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Tests](https://img.shields.io/badge/tests-20%20passing-brightgreen)
+
+`cks-mcp` is an MCP (Model Context Protocol) server that provides LLMs
+with structured, verifiable knowledge operations through the CKS
+ecosystem.  It exposes six tools—validate, query, compare, evolve,
+derive, and construct—each backed by the deterministic, immutable
+semantics of `cks-core`.
+
+---
+
+# Why cks-mcp?
+
+LLMs generate plausible but unverified statements.  `cks-mcp` gives them
+a **canonical knowledge backbone**: every piece of information must be
+explicitly structured, validated against formal constraints, and
+traceable to its origin.  This minimises hallucinations and makes AI‑
+generated knowledge auditable.
+
+---
+
+# Installation
+
+```bash
+pip install cks-mcp
+```
+
+The server requires `cks-core` (installed automatically as a dependency).
+
+---
+
+# Quick Start
+
+Launch the server:
+
+```bash
+cks-mcp
+```
+
+An MCP client (Claude Desktop, any MCP-compatible LLM) can then connect
+and call tools.
+
+---
+
+# Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `validate_knowledge` | Validate a Knowledge Structure and return diagnostics. |
+| `query_relations`   | Find all relations for a given entity. |
+| `compare_structures`| Check semantic equivalence of two structures. |
+| `evolve_knowledge`  | Apply Genesis/Decay operators to evolve a structure. |
+| `derive_knowledge`  | Derive a new Knowledge Object from existing premises. |
+| `construct_knowledge`| Parse and construct a Knowledge Structure (coming soon). |
+
+---
+
+# Usage Example
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "tools/call",
+  "params": {
+    "name": "validate_knowledge",
+    "arguments": {
+      "json_data": "{\"objects\":[{\"identity\":{\"id\":\"obj-1\",\"type\":\"Definition\",\"name\":\"Test\"},\"structure\":{}}]}"
+    }
+  }
+}
+```
+
+Response:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": "{\"valid\": true, \"error_count\": 0, \"warning_count\": 0, \"diagnostics\": []}"
+}
+```
+
+---
+
+# Testing
+
+```bash
+python -m pytest -v
+```
+
+20 tests, all passing.
+
+---
+
+# Ecosystem
+
+- **cks-core** — the canonical knowledge engine ([repo](https://github.com/Deus-corp/CKS))
+- **CKS Specifications** — formal theory behind the system ([DOI](https://zenodo.org/records/21332624))
+
+---
+
+# License
+
+MIT

cks_mcp-0.1.1/src/cks_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/cks_mcp/__init__.py
+src/cks_mcp/server.py
+src/cks_mcp.egg-info/PKG-INFO
+src/cks_mcp.egg-info/SOURCES.txt
+src/cks_mcp.egg-info/dependency_links.txt
+src/cks_mcp.egg-info/entry_points.txt
+src/cks_mcp.egg-info/requires.txt
+src/cks_mcp.egg-info/top_level.txt
+src/cks_mcp/tools/__init__.py
+src/cks_mcp/tools/compare.py
+src/cks_mcp/tools/derive.py
+src/cks_mcp/tools/evolve.py
+src/cks_mcp/tools/query.py
+src/cks_mcp/tools/validate.py
+tests/test_compare.py
+tests/test_derive.py
+tests/test_evolve.py
+tests/test_query.py
+tests/test_server.py
+tests/test_validate.py

cks_mcp-0.1.1/src/cks_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cks_mcp-0.1.1/src/cks_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cks-mcp = cks_mcp.server:main

cks_mcp-0.1.1/src/cks_mcp.egg-info/requires.txt

@@ -0,0 +1,5 @@
+cks-core>=1.1.1
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.24

cks_mcp-0.1.1/src/cks_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+cks_mcp

cks_mcp-0.1.1/tests/test_compare.py

@@ -0,0 +1,42 @@
+"""Tests for compare_structures tool."""
+import json
+from cks_mcp.tools.compare import compare_structures
+
+
+def test_compare_equivalent():
+    """Two identical structures should be equivalent."""
+    data_a = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Test"}, "structure": {}},
+        ]
+    })
+    data_b = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Test"}, "structure": {}},
+        ]
+    })
+    result = json.loads(compare_structures(data_a, data_b))
+    assert result["equivalent"] is True
+
+
+def test_compare_different():
+    """Structures with different objects should not be equivalent."""
+    data_a = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Test"}, "structure": {}},
+        ]
+    })
+    data_b = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-2", "type": "Definition", "name": "Other"}, "structure": {}},
+        ]
+    })
+    result = json.loads(compare_structures(data_a, data_b))
+    assert result["equivalent"] is False
+
+
+def test_compare_parse_error():
+    """Malformed input should return an error."""
+    result = json.loads(compare_structures("not json", json.dumps({"objects": []})))
+    assert result["equivalent"] is False
+    assert "error" in result

cks_mcp-0.1.1/tests/test_derive.py

@@ -0,0 +1,59 @@
+"""Tests for derive_knowledge tool."""
+import json
+from cks_mcp.tools.derive import derive_knowledge
+
+
+def test_derive_success():
+    """Derive a new object from existing premises."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "prem-1", "type": "Axiom", "name": "A"}, "structure": {}},
+            {"identity": {"id": "prem-2", "type": "Axiom", "name": "B"}, "structure": {}},
+        ]
+    })
+    result = derive_knowledge(
+        json_data=data,
+        premises=json.dumps(["prem-1", "prem-2"]),
+        rule="modus_ponens",
+        conclusion_id="conc-1",
+        conclusion_type="Theorem",
+        conclusion_name="C",
+    )
+    assert "conc-1" in result
+
+
+def test_derive_missing_premise():
+    """Derivation with missing premise should return an error."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "prem-1", "type": "Axiom", "name": "A"}, "structure": {}},
+        ]
+    })
+    result = json.loads(derive_knowledge(
+        json_data=data,
+        premises=json.dumps(["prem-1", "prem-missing"]),
+        rule="modus_ponens",
+        conclusion_id="conc-1",
+        conclusion_type="Theorem",
+        conclusion_name="C",
+    ))
+    assert "error" in result
+
+
+def test_derive_duplicate_id():
+    """Derivation with duplicate conclusion ID should return an error."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "prem-1", "type": "Axiom", "name": "A"}, "structure": {}},
+            {"identity": {"id": "conc-1", "type": "Theorem", "name": "Already exists"}, "structure": {}},
+        ]
+    })
+    result = json.loads(derive_knowledge(
+        json_data=data,
+        premises=json.dumps(["prem-1"]),
+        rule="modus_ponens",
+        conclusion_id="conc-1",
+        conclusion_type="Theorem",
+        conclusion_name="C",
+    ))
+    assert "error" in result

cks_mcp-0.1.1/tests/test_evolve.py

@@ -0,0 +1,49 @@
+"""Tests for evolve_knowledge tool."""
+import json
+from cks_mcp.tools.evolve import evolve_knowledge
+
+
+def test_evolve_add_object():
+    """Add a new object via evolution."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Test"}, "structure": {}},
+        ]
+    })
+    ops = json.dumps([
+        {
+            "type": "add_object",
+            "identity": {"id": "obj-2", "type": "Definition", "name": "New"},
+            "structure": {},
+        }
+    ])
+    result = evolve_knowledge(data, ops)
+    assert "obj-2" in result
+    assert "obj-1" in result
+
+
+def test_evolve_remove_object():
+    """Remove an object via evolution."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Test"}, "structure": {}},
+            {"identity": {"id": "obj-2", "type": "Definition", "name": "Other"}, "structure": {}},
+        ]
+    })
+    ops = json.dumps([
+        {"type": "remove_object", "object_id": "obj-2"}
+    ])
+    result = evolve_knowledge(data, ops)
+    assert "obj-1" in result
+    assert "obj-2" not in result
+
+
+def test_evolve_invalid_operations():
+    """Invalid operations should return an error."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Test"}, "structure": {}},
+        ]
+    })
+    result = json.loads(evolve_knowledge(data, "invalid"))
+    assert "error" in result

cks_mcp-0.1.1/tests/test_query.py

@@ -0,0 +1,31 @@
+"""Tests for query_relations tool."""
+import json
+from cks_mcp.tools.query import query_relations
+
+
+def test_query_relations():
+    """Query an entity that has relations."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Alice"}, "structure": {}},
+            {"identity": {"id": "obj-2", "type": "Definition", "name": "Bob"}, "structure": {}},
+            {
+                "identity": {"id": "rel-1", "type": "Relation", "name": "knows"},
+                "structure": {"participants": ["obj-1", "obj-2"], "relation_type": "knows"},
+            },
+        ]
+    })
+    result = json.loads(query_relations(data, "obj-1"))
+    assert len(result["relations"]) == 1
+    assert result["relations"][0]["relation_type"] == "knows"
+
+
+def test_query_no_relations():
+    """Query an entity with no relations."""
+    data = json.dumps({
+        "objects": [
+            {"identity": {"id": "obj-1", "type": "Definition", "name": "Alice"}, "structure": {}},
+        ]
+    })
+    result = json.loads(query_relations(data, "obj-1"))
+    assert len(result["relations"]) == 0

cks_mcp-0.1.1/tests/test_server.py

@@ -0,0 +1,109 @@
+"""Tests for MCP server."""
+import json
+import pytest
+from cks_mcp.server import handle_request
+
+
+@pytest.mark.asyncio
+async def test_tools_list():
+    """tools/list should return available tools."""
+    request = {"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}
+    response = await handle_request(request)
+    assert response["jsonrpc"] == "2.0"
+    assert response["id"] == 1
+    tools = response["result"]
+    assert len(tools) >= 1
+    assert any(t["name"] == "validate_knowledge" for t in tools)
+
+
+@pytest.mark.asyncio
+async def test_tools_call_validate():
+    """tools/call for validate_knowledge should succeed with valid input."""
+    request = {
+        "jsonrpc": "2.0",
+        "id": 2,
+        "method": "tools/call",
+        "params": {
+            "name": "validate_knowledge",
+            "arguments": {
+                "json_data": json.dumps({
+                    "objects": [
+                        {
+                            "identity": {"id": "obj-1", "type": "Definition", "name": "Test"},
+                            "structure": {},
+                        }
+                    ]
+                })
+            },
+        },
+    }
+    response = await handle_request(request)
+    assert response["jsonrpc"] == "2.0"
+    assert response["id"] == 2
+    result = json.loads(response["result"])
+    assert result["valid"] is True
+
+
+@pytest.mark.asyncio
+async def test_tools_call_validate_invalid():
+    """tools/call for validate_knowledge should return error for invalid input."""
+    request = {
+        "jsonrpc": "2.0",
+        "id": 3,
+        "method": "tools/call",
+        "params": {
+            "name": "validate_knowledge",
+            "arguments": {
+                "json_data": json.dumps({
+                    "objects": [
+                        {"identity": {"id": "dup", "type": "X", "name": "x"}, "structure": {}},
+                        {"identity": {"id": "dup", "type": "Y", "name": "y"}, "structure": {}},
+                    ]
+                })
+            },
+        },
+    }
+    response = await handle_request(request)
+    assert response["jsonrpc"] == "2.0"
+    assert response["id"] == 3
+    result = json.loads(response["result"])
+    assert result["valid"] is False
+
+
+@pytest.mark.asyncio
+async def test_tools_call_unknown_tool():
+    """Calling an unknown tool should return an error."""
+    request = {
+        "jsonrpc": "2.0",
+        "id": 4,
+        "method": "tools/call",
+        "params": {
+            "name": "nonexistent",
+            "arguments": {},
+        },
+    }
+    response = await handle_request(request)
+    assert response["jsonrpc"] == "2.0"
+    assert response["id"] == 4
+    assert "error" in response
+    assert response["error"]["code"] == -32601
+
+
+@pytest.mark.asyncio
+async def test_unknown_method():
+    """Calling an unknown method should return an error."""
+    request = {"jsonrpc": "2.0", "id": 5, "method": "unknown/method", "params": {}}
+    response = await handle_request(request)
+    assert response["jsonrpc"] == "2.0"
+    assert response["id"] == 5
+    assert "error" in response
+
+
+@pytest.mark.asyncio
+async def test_missing_method():
+    """Request with missing method should return an error."""
+    request = {"jsonrpc": "2.0", "id": 6}
+    response = await handle_request(request)
+    assert response["jsonrpc"] == "2.0"
+    assert response["id"] == 6
+    assert "error" in response

cks_mcp-0.1.1/tests/test_validate.py

@@ -0,0 +1,40 @@
+"""Tests for validate_knowledge tool."""
+import json
+
+from cks_mcp.tools.validate import validate_knowledge
+
+
+def test_validate_valid_structure():
+    """A valid minimal structure should pass validation."""
+    valid_json = json.dumps({
+        "objects": [
+            {
+                "identity": {"id": "obj-1", "type": "Definition", "name": "Test"},
+                "structure": {},
+            }
+        ]
+    })
+    result = json.loads(validate_knowledge(valid_json))
+    assert result["valid"] is True
+    assert result["error_count"] == 0
+
+
+def test_validate_invalid_structure():
+    """An invalid structure (duplicate IDs) should fail."""
+    invalid_json = json.dumps({
+        "objects": [
+            {"identity": {"id": "dup", "type": "Definition", "name": "First"}, "structure": {}},
+            {"identity": {"id": "dup", "type": "Definition", "name": "Second"}, "structure": {}},
+        ]
+    })
+    result = json.loads(validate_knowledge(invalid_json))
+    assert result["valid"] is False
+    # Should be a parse error (duplicate identity detected by parser)
+    assert "Duplicate" in result.get("error", "")
+
+
+def test_validate_malformed_json():
+    """Malformed JSON should return an error."""
+    result = json.loads(validate_knowledge("not json"))
+    assert result["valid"] is False
+    assert "error" in result