technical-answer-validator 0.1.0__py3-none-any.whl

mcp_server.py

@@ -0,0 +1,46 @@
+"""MCP stdio server exposing the answer evaluator as an agent tool."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from mcp.server import MCPServer
+
+from tav_core import RequestError, evaluate
+
+logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(message)s")
+mcp = MCPServer(
+    "Technical Answer Validator",
+    instructions=(
+        "Evaluate a user's technical answer against a rubric supplied for this call. "
+        "Always pass the caller's rubric and answer. Explain that results are keyword-based "
+        "assistive feedback, never official exam grades; preserve review_required in your response."
+    ),
+)
+
+
+@mcp.tool()
+def evaluate_answer(rubric: dict[str, Any], answer: str) -> dict[str, Any]:
+    """Check an answer against caller-provided concepts, synonyms, and numeric requirements.
+
+    Rubric fields: required_concepts (1-50 strings), optional accepted_synonyms keyed by
+    concept, optional numeric_requirements [{value, unit?, tolerance?}], and optional
+    required_count. No question bank is bundled. Review the returned result; it is not
+    an official exam grade.
+    """
+    try:
+        return evaluate({"rubric": rubric, "answer": answer})
+    except RequestError as exc:
+        # Return a structured error result so the agent can repair its inputs.
+        return {"status": "invalid_request", "error": str(exc), "review_required": True}
+
+
+def main() -> None:
+    # FastMCP stdio transport uses stdout for protocol messages; keep diagnostics on stderr.
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

tav_api.py

@@ -0,0 +1,224 @@
+"""Minimal standard-library HTTP adapter for the TAV MVP."""
+
+from __future__ import annotations
+
+from collections import defaultdict, deque
+from contextlib import closing
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import hashlib
+import hmac
+import json
+import re
+import os
+import sqlite3
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from tav_core import RequestError, evaluate
+
+MAX_BODY = 64 * 1024
+RATE_LIMIT = 60
+RATE_WINDOW = 60
+_requests: dict[str, deque[float]] = defaultdict(deque)
+MAX_RATE_CLIENTS = 10000
+
+
+def _usage_db() -> Path:
+    return Path(os.environ.get("TAV_USAGE_DB", "usage.sqlite3"))
+
+
+def _api_key_id(supplied_header: str) -> str | None:
+    """Resolve bearer credentials against SHA-256 digests in TAV_API_KEYS."""
+    if not supplied_header.startswith("Bearer "):
+        return None
+    token = supplied_header[7:]
+    configured = os.environ.get("TAV_API_KEYS", "")
+    if configured:
+        try:
+            key_map = json.loads(configured)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError("TAV_API_KEYS must be a JSON object of client_id to SHA-256 hex digest") from exc
+        if not isinstance(key_map, dict):
+            raise RuntimeError("TAV_API_KEYS must be a JSON object")
+        digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
+        for client_id, expected_digest in key_map.items():
+            if not isinstance(client_id, str) or not re.fullmatch(r"[A-Za-z0-9_-]{1,48}", client_id):
+                continue
+            if isinstance(expected_digest, str) and hmac.compare_digest(digest, expected_digest.lower()):
+                return client_id
+        return None
+    # Single-key mode is for local development and backwards-compatible self-hosting.
+    expected = os.environ.get("TAV_API_KEY", "")
+    return "default" if expected and hmac.compare_digest(token, expected) else None
+
+
+def _record_usage(client_id: str, kind: str) -> None:
+    """Persist aggregate counters only; never store request content or answers."""
+    path = _usage_db()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    today = datetime.now(timezone.utc).date().isoformat()
+    with closing(sqlite3.connect(path, timeout=5)) as connection:
+        with connection:
+            connection.execute("""CREATE TABLE IF NOT EXISTS daily_usage (
+                day TEXT NOT NULL, client_id TEXT NOT NULL, requests INTEGER NOT NULL DEFAULT 0,
+                successful INTEGER NOT NULL DEFAULT 0, client_errors INTEGER NOT NULL DEFAULT 0,
+                rate_limited INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(day, client_id))""")
+            columns = {"success": "successful", "client_error": "client_errors", "rate_limited": "rate_limited"}
+            if kind not in {"success", "client_error", "rate_limited", "server_error"}:
+                raise ValueError("invalid usage event")
+            connection.execute("DELETE FROM daily_usage WHERE day < ?", ((datetime.now(timezone.utc).date() - timedelta(days=89)).isoformat(),))
+            connection.execute("INSERT OR IGNORE INTO daily_usage(day, client_id) VALUES(?, ?)", (today, client_id))
+            column = columns.get(kind)
+            if column:
+                connection.execute(f"UPDATE daily_usage SET requests=requests+1, {column}={column}+1 WHERE day=? AND client_id=?", (today, client_id))
+            else:
+                connection.execute("UPDATE daily_usage SET requests=requests+1 WHERE day=? AND client_id=?", (today, client_id))
+
+
+def _read_usage(client_id: str) -> dict[str, int | str]:
+    path = _usage_db()
+    today = datetime.now(timezone.utc).date().isoformat()
+    if not path.exists():
+        return {"date_utc": today, "requests": 0, "successful": 0, "client_errors": 0, "rate_limited": 0}
+    with closing(sqlite3.connect(path, timeout=5)) as connection:
+        row = connection.execute(
+            "SELECT day, requests, successful, client_errors, rate_limited FROM daily_usage WHERE day=? AND client_id=?",
+            (today, client_id),
+        ).fetchone()
+    if not row:
+        return {"date_utc": today, "requests": 0, "successful": 0, "client_errors": 0, "rate_limited": 0}
+    if row[0] != today:
+        return {"date_utc": today, "requests": 0, "successful": 0, "client_errors": 0, "rate_limited": 0}
+    return {"date_utc": row[0], "requests": row[1], "successful": row[2], "client_errors": row[3], "rate_limited": row[4]}
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "TAV/0.1"
+
+    def log_message(self, fmt: str, *args: object) -> None:
+        # Avoid default logging of client address and request details.
+        return
+
+    def _send(self, status: int, data: dict) -> None:
+        body = json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _error(self, status: int, code: str, message: str) -> None:
+        self._send(status, {"error": {"code": code, "message": message}})
+
+    def do_GET(self) -> None:
+        if self.path == "/healthz":
+            self._send(200, {"status": "ok"})
+            return
+        if self.path == "/v1/usage":
+            client_id = _api_key_id(self.headers.get("Authorization", ""))
+            if client_id is None:
+                self._error(401, "unauthorized", "A valid bearer API key is required")
+                return
+            self._send(200, _read_usage(client_id))
+            return
+        self._error(404, "not_found", "Route not found")
+
+    def do_POST(self) -> None:
+        if self.path != "/v1/evaluate":
+            self._error(404, "not_found", "Route not found")
+            return
+        client_id = _api_key_id(self.headers.get("Authorization", ""))
+        if client_id is None:
+            self._error(401, "unauthorized", "A valid bearer API key is required")
+            return
+
+        now = time.monotonic()
+        if client_id not in _requests and len(_requests) >= MAX_RATE_CLIENTS:
+            _requests.pop(next(iter(_requests)))
+        history = _requests[client_id]
+        while history and now - history[0] >= RATE_WINDOW:
+            history.popleft()
+        if len(history) >= RATE_LIMIT:
+            _record_usage(client_id, "rate_limited")
+            self._error(429, "rate_limited", "Request limit exceeded")
+            return
+        history.append(now)
+
+        try:
+            length = int(self.headers.get("Content-Length", "-1"))
+        except ValueError:
+            _record_usage(client_id, "client_error")
+            self._error(400, "invalid_content_length", "Content-Length must be an integer")
+            return
+        if length < 0:
+            _record_usage(client_id, "client_error")
+            self._error(400, "content_length_required", "Content-Length is required")
+            return
+        if length > MAX_BODY:
+            _record_usage(client_id, "client_error")
+            self._error(413, "body_too_large", "Request body exceeds 64 KiB")
+            return
+        content_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower()
+        if content_type != "application/json":
+            _record_usage(client_id, "client_error")
+            self._error(415, "unsupported_media_type", "Content-Type must be application/json")
+            return
+        raw = self.rfile.read(length)
+        try:
+            payload = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            _record_usage(client_id, "client_error")
+            self._error(400, "invalid_json", "Body must be valid UTF-8 JSON")
+            return
+        try:
+            result = evaluate(payload)
+        except RequestError as exc:
+            _record_usage(client_id, "client_error")
+            self._error(400, "invalid_request", str(exc))
+            return
+        _record_usage(client_id, "success")
+        self._send(200, result)
+
+    def do_PUT(self) -> None:
+        self._error(405, "method_not_allowed", "Method not allowed")
+
+    do_PATCH = do_PUT
+    do_DELETE = do_PUT
+
+
+def main() -> None:
+    key = os.environ.get("TAV_API_KEY", "")
+    key_map = os.environ.get("TAV_API_KEYS", "")
+    if key_map:
+        try:
+            parsed_keys = json.loads(key_map)
+        except json.JSONDecodeError:
+            raise SystemExit("TAV_API_KEYS must be JSON mapping client IDs to SHA-256 digests") from None
+        if not isinstance(parsed_keys, dict) or not parsed_keys:
+            raise SystemExit("TAV_API_KEYS must contain at least one client key")
+        if any(
+            not isinstance(client_id, str)
+            or not re.fullmatch(r"[A-Za-z0-9_-]{1,48}", client_id)
+            or not isinstance(digest, str)
+            or not re.fullmatch(r"[a-fA-F0-9]{64}", digest)
+            for client_id, digest in parsed_keys.items()
+        ):
+            raise SystemExit("TAV_API_KEYS entries must use valid client IDs and 64-character SHA-256 hex digests")
+    elif len(key) < 24:
+        raise SystemExit("Set TAV_API_KEYS or TAV_API_KEY (at least 24 characters for single-key mode)")
+    host = os.environ.get("TAV_HOST", "127.0.0.1")
+    port = int(os.environ.get("TAV_PORT", "8080"))
+    server = ThreadingHTTPServer((host, port), Handler)
+    print(f"TAV listening on {host}:{port}; request bodies are not logged")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+
+
+if __name__ == "__main__":
+    main()

tav_core.py

@@ -0,0 +1,206 @@
+"""Deterministic grading against caller-supplied rubric data only."""
+
+from __future__ import annotations
+
+import json
+import re
+from difflib import SequenceMatcher
+from decimal import Decimal, InvalidOperation
+from typing import Any
+
+
+class RequestError(ValueError):
+    """Input does not satisfy the API contract."""
+
+
+_NUMBER_RE = re.compile(r"\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:[.,]\d+)?")
+_ALLOWED_RUBRIC = {"required_concepts", "accepted_synonyms", "numeric_requirements", "required_count"}
+
+
+def _normalize(value: str) -> str:
+    return re.sub(r"[\W_]+", "", value.casefold(), flags=re.UNICODE)
+
+
+def _ensure_utf8(value: Any) -> None:
+    if isinstance(value, str):
+        try:
+            value.encode("utf-8")
+        except UnicodeEncodeError:
+            raise RequestError("all input strings must be valid Unicode") from None
+    elif isinstance(value, dict):
+        for key, item in value.items():
+            _ensure_utf8(key)
+            _ensure_utf8(item)
+    elif isinstance(value, list):
+        for item in value:
+            _ensure_utf8(item)
+
+
+def _match_concept(concept: str, synonyms: list[str], answer: str) -> bool:
+    candidates = [concept, *synonyms]
+    norm_answer = _normalize(answer)
+    for candidate in candidates:
+        norm = _normalize(candidate)
+        if norm and norm in norm_answer:
+            return True
+
+    # Conservative typo tolerance: only for candidates of 5+ characters,
+    # using sliding windows to avoid comparing against the whole paragraph.
+    for candidate in candidates:
+        norm = _normalize(candidate)
+        if len(norm) < 5:
+            continue
+        window_count = max(1, len(norm_answer) - len(norm) + 1)
+        stride = max(1, (window_count + 255) // 256)
+        for start in range(0, window_count, stride):
+            window = norm_answer[start : start + len(norm)]
+            if SequenceMatcher(None, norm, window).ratio() >= 0.88:
+                return True
+    return False
+
+
+def _validate_rubric(rubric: Any) -> tuple[list[str], dict[str, list[str]], list[dict[str, str]], int]:
+    if not isinstance(rubric, dict):
+        raise RequestError("rubric must be an object")
+    extra = set(rubric) - _ALLOWED_RUBRIC
+    if extra:
+        raise RequestError(f"unknown rubric field: {sorted(extra)[0]}")
+
+    concepts = rubric.get("required_concepts")
+    if not isinstance(concepts, list) or not 1 <= len(concepts) <= 50:
+        raise RequestError("required_concepts must be an array with 1 to 50 items")
+    if any(not isinstance(item, str) or not item.strip() or len(item) > 120 for item in concepts):
+        raise RequestError("each concept must be a non-empty string of at most 120 characters")
+    if len({_normalize(x) for x in concepts}) != len(concepts):
+        raise RequestError("required_concepts must be unique after normalization")
+
+    if len(json.dumps(rubric, ensure_ascii=False).encode("utf-8")) > 8192:
+        raise RequestError("rubric must not exceed 8 KiB")
+
+    synonym_map = rubric.get("accepted_synonyms", {})
+    if not isinstance(synonym_map, dict) or set(synonym_map) - set(concepts):
+        raise RequestError("accepted_synonyms must map existing concepts to arrays")
+    synonyms: dict[str, list[str]] = {}
+    term_owners: dict[str, str] = {}
+    for concept in concepts:
+        term_owners[_normalize(concept)] = concept
+    for concept, values in synonym_map.items():
+        if not isinstance(values, list) or len(values) > 20:
+            raise RequestError("each synonym list must contain at most 20 strings")
+        if any(not isinstance(value, str) or not value.strip() or len(value) > 120 for value in values):
+            raise RequestError("synonyms must be non-empty strings of at most 120 characters")
+        synonyms[concept] = values
+        for value in values:
+            normalized = _normalize(value)
+            owner = term_owners.get(normalized)
+            if owner is not None and owner != concept:
+                raise RequestError("a concept or synonym cannot belong to multiple concepts")
+            term_owners[normalized] = concept
+    if sum(1 + len(synonyms.get(concept, [])) for concept in concepts) > 100:
+        raise RequestError("required concepts and synonyms may contain at most 100 total terms")
+
+    numeric = rubric.get("numeric_requirements", [])
+    if not isinstance(numeric, list) or len(numeric) > 20:
+        raise RequestError("numeric_requirements must be an array with at most 20 items")
+    normalized_numeric: list[dict[str, str]] = []
+    for item in numeric:
+        if not isinstance(item, dict) or set(item) - {"value", "unit", "tolerance"} or "value" not in item:
+            raise RequestError("each numeric requirement needs value and optional unit/tolerance")
+        try:
+            expected_decimal = Decimal(str(item["value"]))
+            tolerance_decimal = Decimal(str(item.get("tolerance", "0")))
+            if not expected_decimal.is_finite() or not tolerance_decimal.is_finite() or tolerance_decimal < 0:
+                raise InvalidOperation
+            value = str(expected_decimal)
+            tolerance = str(tolerance_decimal)
+        except (InvalidOperation, ValueError):
+            raise RequestError("numeric value and non-negative tolerance must be decimals") from None
+        unit = item.get("unit", "")
+        if not isinstance(unit, str) or len(unit) > 24:
+            raise RequestError("numeric unit must be a string of at most 24 characters")
+        normalized_numeric.append({"value": value, "unit": unit, "tolerance": tolerance})
+
+    required_count = rubric.get("required_count", len(concepts))
+    if not isinstance(required_count, int) or isinstance(required_count, bool) or not 1 <= required_count <= len(concepts):
+        raise RequestError("required_count must be an integer from 1 to the number of concepts")
+    return concepts, synonyms, normalized_numeric, required_count
+
+
+def _parse_number(raw: str) -> Decimal | None:
+    if "," in raw:
+        if re.fullmatch(r"\d{1,3}(?:,\d{3})+(?:\.\d+)?", raw):
+            raw = raw.replace(",", "")
+        elif raw.count(",") == 1 and "." not in raw:
+            raw = raw.replace(",", ".")
+        else:
+            return None
+    try:
+        value = Decimal(raw)
+    except InvalidOperation:
+        return None
+    return value if value.is_finite() else None
+
+
+def _check_numbers(answer: str, requirements: list[dict[str, str]]) -> list[dict[str, Any]]:
+    checks = []
+    for requirement in requirements:
+        expected = Decimal(requirement["value"])
+        tolerance = Decimal(requirement["tolerance"])
+        unit = requirement["unit"]
+        observed: list[Decimal] = []
+        candidates = list(_NUMBER_RE.finditer(answer))
+        for match in candidates:
+            suffix = answer[match.end() : match.end() + len(unit) + 8].lstrip() if unit else ""
+            if unit:
+                unit_match = re.match(re.escape(unit) + r"(?![\w])", suffix, flags=re.IGNORECASE | re.UNICODE)
+                if not unit_match:
+                    continue
+            actual = _parse_number(match.group())
+            if actual is not None:
+                observed.append(actual)
+        passed = bool(observed) and all(abs(actual - expected) <= tolerance for actual in observed)
+        checks.append({
+            "expected": requirement["value"],
+            "unit": unit,
+            "tolerance": requirement["tolerance"],
+            "observed": [str(value) for value in observed],
+            "passed": passed,
+        })
+    return checks
+
+
+def evaluate(payload: Any) -> dict[str, Any]:
+    _ensure_utf8(payload)
+    if not isinstance(payload, dict) or set(payload) != {"rubric", "answer"}:
+        raise RequestError("request must contain exactly rubric and answer")
+    answer = payload["answer"]
+    if not isinstance(answer, str) or not answer.strip() or len(answer) > 8000:
+        raise RequestError("answer must be a string of at most 8000 characters")
+    rubric = payload["rubric"]
+    concepts, synonyms, numeric, required_count = _validate_rubric(rubric)
+
+    matched = [concept for concept in concepts if _match_concept(concept, synonyms.get(concept, []), answer)]
+    missing = [concept for concept in concepts if concept not in matched]
+    score = min(len(matched) / required_count, 1.0)
+    numeric_checks = _check_numbers(answer, numeric)
+    if any(not check["passed"] for check in numeric_checks):
+        score *= 0.5
+    score = round(score, 3)
+    verdict = "correct" if score >= 0.8 else "partial" if score >= 0.4 else "wrong"
+    notes = []
+    if len(matched) < required_count:
+        notes.append(f"required_count={required_count}; matched={len(matched)}")
+    if any(not check["passed"] for check in numeric_checks):
+        notes.append("One or more numeric requirements did not match.")
+    return {
+        "api_version": "v1",
+        "status": "graded",
+        "score": score,
+        "verdict": verdict,
+        "matched_concepts": matched,
+        "missing_concepts": missing,
+        "numeric_checks": numeric_checks,
+        "notes": notes,
+        "review_required": True,
+        "limitations": ["Keyword-based assistive review only; not an official exam grade."],
+    }

technical_answer_validator-0.1.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.5
+Name: technical-answer-validator
+Version: 0.1.0
+Summary: MCP and REST tools for deterministic rubric-based technical answer review
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp==2.2.0
+Description-Content-Type: text/markdown
+
+# Technical Answer Validator
+
+<!-- mcp-name: io.github.christofer566/technical-answer-validator -->
+
+A tiny, deterministic answer review tool for AI agents, available over **MCP stdio** and as a REST API. Each caller supplies the concepts, accepted synonyms, numeric requirements, and answer text for a single evaluation. It does not include a question bank or answer corpus.
+
+This is an **assistive practice tool**, not an official certification exam grader. Keyword matching can miss semantically correct paraphrases and can accept misleading surface matches. Users should review the supplied rubric and every result.
+
+## Run locally
+
+Python 3.10+; the REST server uses the standard library. The MCP adapter uses the official Python SDK 2.2.0.
+
+```powershell
+$env:TAV_API_KEY = "replace-with-a-long-random-secret-at-least-24-characters"
+python -m tav_api
+```
+
+The service listens on `127.0.0.1:8080` by default. To change it, set `TAV_HOST` and `TAV_PORT`. Local single-key mode refuses to start without a `TAV_API_KEY` of at least 24 characters. For deployment, create a distinct key per caller with `python scripts/create_api_key.py CLIENT_ID` and configure `TAV_API_KEYS` as a JSON object mapping each client ID to the generated SHA-256 digest. Store the one-time raw key with that client; do not store or commit it in this repository. When `TAV_API_KEYS` is set, it takes precedence over `TAV_API_KEY`.
+
+## MCP for AI agents
+
+Install the pinned MCP SDK 2.2.0 in a virtual environment from the committed lockfile:
+
+```powershell
+uv sync --locked
+.\.venv\Scripts\Activate.ps1
+```
+
+The stdio MCP server exposes one tool: `evaluate_answer(rubric, answer)`. Configure an MCP host with the absolute path to the environment's Python and `mcp_server.py`. Example Claude Desktop configuration (replace paths):
+
+```json
+{
+  "mcpServers": {
+    "technical-answer-validator": {
+      "command": "C:\\path\\to\\technical-answer-validator\\.venv\\Scripts\\python.exe",
+      "args": ["C:\\path\\to\\technical-answer-validator\\mcp_server.py"]
+    }
+  }
+}
+```
+
+After publishing to PyPI, run with `uvx --from technical-answer-validator tav-mcp`. For local development use the `.venv` Python plus `mcp_server.py`. For Codex CLI or another MCP host, use its stdio server configuration with that command and script path. Restart the host, then ask it to list tools and call `evaluate_answer`. The stdio transport is local to the user's agent host and needs no internet endpoint or API key.
+
+The Codex TOML template is `codex-mcp-config.example.toml`; the Claude Desktop JSON template is `claude-mcp-config.example.json`. Replace both placeholder paths with absolute paths. Merge the block into the host configuration; do not overwrite other MCP servers or global settings.
+
+## Request
+
+`POST /v1/evaluate`
+
+```json
+{
+  "rubric": {
+    "required_concepts": ["isolation", "lockout tag"],
+    "accepted_synonyms": {"isolation": ["energy isolation"]},
+    "numeric_requirements": [],
+    "required_count": 2
+  },
+  "answer": "Apply energy isolation and attach a lockout tag."
+}
+```
+
+`accepted_synonyms` keys must exactly match a concept. `numeric_requirements` is an optional array such as `[{"value":"10","unit":"kN","tolerance":"0"}]`. Numbers in an answer are only checked when explicit requirements are provided. Concept score is matched concepts / required_count (defaults to the number of concepts), capped at 1.0; numeric failures apply a 50% score penalty. The verdict thresholds are `correct >= 0.8`, `partial >= 0.4`, otherwise `wrong`.
+
+## Response and errors
+
+Successful requests return `api_version`, `status`, `score`, `verdict`, matched/missing concepts, numeric check details, and `review_required: true`.
+
+Errors use JSON `{ "error": { "code": "...", "message": "..." } }`. Statuses include 400 (invalid request), 401 (missing/invalid key), 404, 405, 413 (body over 64 KiB), and 429 (over 60 requests/minute per client ID). The rate limit is 60 requests/minute per authenticated client ID, in memory, and resets when the process restarts. Daily request/success/client-error/rate-limited counters are persisted in SQLite without answer text and expire after 90 days. `GET /v1/usage` returns only the caller's current UTC-day counts. Retain and back up the usage volume as desired; it contains client IDs and aggregates only.
+
+## Privacy and deployment limits
+
+The server does not log request bodies or answers. It stores daily counts keyed by client ID and request timestamps in process memory for REST rate limiting. The **stdio MCP option runs locally inside the agent host** and sends no requests to this HTTP server. The REST API is containerized and keeps usage counters in a persistent volume. Before public service, terminate TLS at a reverse proxy, set proxy-level rate/concurrency limits, deploy from a secret manager, monitor the host, and publish a data-retention/contact policy. The app-level per-client rate limit resets on restart and is not a substitute for edge controls.
+
+## Verify
+
+```powershell
+python -m unittest discover -s tests -v
+```
+
+The OpenAPI contract is in `openapi.yaml`; the draft official MCP Registry descriptor is `server.json`, with publication steps in `PUBLISHING.md`. Run locally with Docker Compose after copying `.env.example` to `.env` and adding a private key; Compose publishes the service only on loopback, so configure an HTTPS reverse proxy separately. `compose.yaml` persists aggregate usage in a named volume and applies a read-only root filesystem, dropped Linux capabilities, and resource limits.
+
+These tests check API and grading behavior; they do not establish professional exam accuracy.

technical_answer_validator-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mcp_server.py,sha256=ERHVEgOxppUkWT2lrJzABozeyOU0A5UIHu2vI78xkfM,1617
+tav_api.py,sha256=x9_J_l2TElqynRT0pyjKvsK94t4sFVinws_-c76B2EU,9735
+tav_core.py,sha256=iRidyFalhizO5bLYAhoDZ9NlEdak6HOXOBq_7rDaejw,9208
+technical_answer_validator-0.1.0.dist-info/METADATA,sha256=orfG2Z25RmqTdvEjM6877rs-YPdarGh0cG9jzG4vRD0,5931
+technical_answer_validator-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+technical_answer_validator-0.1.0.dist-info/entry_points.txt,sha256=JmuLu79ZYGv5TmvlG7JBOIwa8BN8bkSDTvIc8OfzPVA,67
+technical_answer_validator-0.1.0.dist-info/licenses/LICENSE,sha256=cRMNPhwVrOILz60oLjerOJC23KvqHr1EEJFBKCMOenI,1062
+technical_answer_validator-0.1.0.dist-info/RECORD,,

technical_answer_validator-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

technical_answer_validator-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+tav-api = tav_api:main
+tav-mcp = mcp_server:main

technical_answer_validator-0.1.0.dist-info/licenses/LICENSE

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