zetesis 0.1.0__tar.gz

zetesis-0.1.0/LICENSE

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

zetesis-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: zetesis
+Version: 0.1.0
+Summary: MCP client for Zetesis: scientific due diligence on a claim, evaluated by a hosted engine and sealed in a verifiable attestation.
+Project-URL: Homepage, https://api.zetesis.science
+Project-URL: Signup, https://api.zetesis.science/signup
+Author-email: Reut Avidan <reutavidan@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: biotech,claim-verification,due-diligence,evaluation,mcp,research,science
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.2.0
+Description-Content-Type: text/markdown
+
+# Zetesis
+
+Scientific due diligence on a claim, from inside Claude, Copilot, or any MCP host.
+
+Zetesis takes a high-dimensional scientific or technical claim and grades it
+dimension by dimension against public literature, clinical trials, and filings.
+It returns an overall reading, cites every source by id, and, for a full
+evaluation, translates the science into what a commitment to the claim turns on
+and seals the result in an attestation anyone can re-check.
+
+This package is a thin MCP client. It holds no keys and runs no model. Every call
+is proxied to the hosted engine at <https://api.zetesis.science> with your token.
+
+## Get a token
+
+Free, no card, at <https://api.zetesis.science/signup>. The free plan gives you a
+handful of screening evaluations each month.
+
+## Connect it
+
+Claude Code:
+
+```bash
+claude mcp add zetesis --env ZETESIS_TOKEN=zk_... -- uvx --from zetesis zetesis-client
+```
+
+Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "zetesis": {
+      "command": "uvx",
+      "args": ["--from", "zetesis", "zetesis-client"],
+      "env": { "ZETESIS_TOKEN": "zk_..." }
+    }
+  }
+}
+```
+
+## Tools
+
+- **evaluate_claim** — grade a claim. `depth="screen"` returns the verdict directly
+  (free tier); `depth="deep"` runs the full signed dossier in the background.
+  `mode="research"` is science only; `mode="diligence"` adds the capital reading.
+- **check_evaluation** — get the verdict and the rendered dossier link for a deep run.
+- **verify_attestation** — re-check any Zetesis attestation. No account needed.
+- **account_status** — your plan and remaining evaluations or credits.
+
+## How it grades
+
+It grades only what the evidence supports, cites sources by hard id (PMID, DOI,
+NCT, NIH grant, SEC filing), and flags gaps rather than filling them. It never
+invents citations. Claim text is not logged; only metadata (the routed domain,
+depth, counts) is kept.
+
+## Configuration
+
+- `ZETESIS_TOKEN` — your token (required for evaluations; verify works without one)
+- `ZETESIS_API` — override the API base (default `https://api.zetesis.science`)
+
+MIT licensed. The hosted engine is a separate service.

zetesis-0.1.0/PUBLISH.md

@@ -0,0 +1,53 @@
+# Publish `zetesis` to PyPI
+
+The package is built and validated in `dist/`. Publishing is your action because
+it needs your PyPI account, and it is permanent (a version number can never be
+reused or reclaimed).
+
+## 1. One-time: PyPI account + token
+
+- Create an account at <https://pypi.org> (verify the email).
+- Account settings → API tokens → **Add API token**. Scope it to "Entire account"
+  for the first upload (you can narrow it to the `zetesis` project afterward).
+- Copy the token (starts with `pypi-`). It is shown once.
+
+## 2. Publish
+
+From this folder:
+
+```bash
+cd /Users/reutavidan/zetesis/01-current/zetesis-pypi
+UV_PUBLISH_TOKEN=pypi-XXXX uv publish
+```
+
+(Equivalent with twine: `uvx twine upload -u __token__ -p pypi-XXXX dist/*`.)
+
+## 3. Verify it is live
+
+```bash
+uvx --from zetesis zetesis-client   # should start (Ctrl+C to stop); confirms install works
+```
+
+Then the marketplace / user config just uses the published name:
+
+```bash
+claude mcp add zetesis --env ZETESIS_TOKEN=zk_... -- uvx --from zetesis zetesis-client
+```
+
+## Optional: dry run on TestPyPI first
+
+```bash
+UV_PUBLISH_TOKEN=pypi-TESTTOKEN uv publish --publish-url https://test.pypi.org/legacy/
+```
+
+## Future releases
+
+Bump `version` in `pyproject.toml`, then `uv build` and `uv publish` again. You
+cannot overwrite 0.1.0; the next upload must be 0.1.1 or higher.
+
+## After publishing: list on the marketplaces
+
+- **Anthropic MCP directory**: submit the server (name, description, the `uvx --from
+  zetesis zetesis-client` command, the tool list). Goes through a review.
+- **Microsoft Copilot store**: submit as a connector.
+Two named reference users help both, since neither store features a zero-usage server.

zetesis-0.1.0/README.md

@@ -0,0 +1,62 @@
+# Zetesis
+
+Scientific due diligence on a claim, from inside Claude, Copilot, or any MCP host.
+
+Zetesis takes a high-dimensional scientific or technical claim and grades it
+dimension by dimension against public literature, clinical trials, and filings.
+It returns an overall reading, cites every source by id, and, for a full
+evaluation, translates the science into what a commitment to the claim turns on
+and seals the result in an attestation anyone can re-check.
+
+This package is a thin MCP client. It holds no keys and runs no model. Every call
+is proxied to the hosted engine at <https://api.zetesis.science> with your token.
+
+## Get a token
+
+Free, no card, at <https://api.zetesis.science/signup>. The free plan gives you a
+handful of screening evaluations each month.
+
+## Connect it
+
+Claude Code:
+
+```bash
+claude mcp add zetesis --env ZETESIS_TOKEN=zk_... -- uvx --from zetesis zetesis-client
+```
+
+Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "zetesis": {
+      "command": "uvx",
+      "args": ["--from", "zetesis", "zetesis-client"],
+      "env": { "ZETESIS_TOKEN": "zk_..." }
+    }
+  }
+}
+```
+
+## Tools
+
+- **evaluate_claim** — grade a claim. `depth="screen"` returns the verdict directly
+  (free tier); `depth="deep"` runs the full signed dossier in the background.
+  `mode="research"` is science only; `mode="diligence"` adds the capital reading.
+- **check_evaluation** — get the verdict and the rendered dossier link for a deep run.
+- **verify_attestation** — re-check any Zetesis attestation. No account needed.
+- **account_status** — your plan and remaining evaluations or credits.
+
+## How it grades
+
+It grades only what the evidence supports, cites sources by hard id (PMID, DOI,
+NCT, NIH grant, SEC filing), and flags gaps rather than filling them. It never
+invents citations. Claim text is not logged; only metadata (the routed domain,
+depth, counts) is kept.
+
+## Configuration
+
+- `ZETESIS_TOKEN` — your token (required for evaluations; verify works without one)
+- `ZETESIS_API` — override the API base (default `https://api.zetesis.science`)
+
+MIT licensed. The hosted engine is a separate service.

zetesis-0.1.0/REGISTRY.md

@@ -0,0 +1,43 @@
+# Listing Zetesis on the MCP registry and the Claude Connectors Directory
+
+Do this after publishing `zetesis` to PyPI (see PUBLISH.md).
+
+## 1. Official MCP Registry (the canonical feed)
+
+The registry is the hub; downstream directories (Smithery, Glama, MCP.so, PulseMCP)
+pull from it. `server.json` is ready in this folder.
+
+- **Namespace + verification.** `server.json` uses `science.zetesis/zetesis`, which
+  requires proving you control zetesis.science (a DNS TXT record or a file the
+  registry publisher tells you to serve). Alternatively switch the name to
+  `io.github.reutavidan/zetesis` and verify with your GitHub account, which is
+  quicker.
+- **Publish.** Install the registry publisher CLI (`mcp-publisher`), authenticate
+  for your namespace, and run it against `server.json`. It validates the file
+  against the current schema and pushes the listing. Follow the current steps at
+  <https://modelcontextprotocol.io/registry/about> (the schema and CLI evolve, so
+  validate against the live schema when you submit).
+
+## 2. Claude Connectors Directory (to be inside Claude)
+
+Separate from the registry, and reviewed by Anthropic. This listing is the credential
+and is what lets Claude surface Zetesis to users automatically.
+
+Two things the review checks, both already handled:
+- **Read-only tool annotations.** All four tools are annotated `readOnlyHint: true`
+  in the client, so nothing looks destructive.
+- **A public privacy policy.** Live at <https://api.zetesis.science/privacy>. A missing
+  or incomplete policy is an automatic rejection.
+
+Submit through the Anthropic connectors submission flow with: the name, the discovery
+description, the `uvx --from zetesis zetesis-client` command (env `ZETESIS_TOKEN`
+optional, only for the full dossier), the privacy policy URL, and the tool list.
+
+## 3. Discovery is earned, not bought
+
+Ranking in the Connectors Directory is by adoption (active users, tool calls), shown
+in a developer dashboard, with no paid placement. Claude surfaces a connector by
+matching the user's intent against tool **names, descriptions, and parameter names**,
+so the descriptions in `client.py` are the discovery surface. Own the phrasings you
+want to win ("evaluate a scientific claim", "how rigorous is this study", "audit this
+biotech or AI claim") and the free screen becomes your spontaneous top-of-funnel.

zetesis-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "zetesis"
+version = "0.1.0"
+description = "MCP client for Zetesis: scientific due diligence on a claim, evaluated by a hosted engine and sealed in a verifiable attestation."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Reut Avidan", email = "reutavidan@gmail.com" }]
+keywords = ["mcp", "science", "due-diligence", "evaluation", "claim-verification", "biotech", "research"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering",
+]
+dependencies = ["mcp>=1.2.0"]
+
+[project.urls]
+Homepage = "https://api.zetesis.science"
+Signup = "https://api.zetesis.science/signup"
+
+[project.scripts]
+zetesis-client = "zetesis.client:main"
+zetesis = "zetesis.client:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/zetesis"]

zetesis-0.1.0/server.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-07-09/server.schema.json",
+  "name": "science.zetesis/zetesis",
+  "description": "Scientific due diligence on a claim. Evaluate how rigorously a scientific, biomedical, clinical, or AI claim was derived, and how well public literature, clinical trials, and filings support it, with a signed, independently re-checkable attestation. Free screen; gated full dossier.",
+  "status": "active",
+  "version": "0.1.0",
+  "websiteUrl": "https://api.zetesis.science",
+  "packages": [
+    {
+      "registryType": "pypi",
+      "registryBaseUrl": "https://pypi.org",
+      "identifier": "zetesis",
+      "version": "0.1.0",
+      "transport": { "type": "stdio" },
+      "runtimeHint": "uvx",
+      "environmentVariables": [
+        {
+          "name": "ZETESIS_TOKEN",
+          "description": "Zetesis access token. Only needed for a full attested dossier; the free screen needs none. Request access at https://api.zetesis.science/request-access.",
+          "isRequired": false,
+          "isSecret": true
+        }
+      ]
+    }
+  ]
+}

zetesis-0.1.0/src/zetesis/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

zetesis-0.1.0/src/zetesis/client.py

@@ -0,0 +1,167 @@
+"""Thin-client MCP server. Proxies to the hosted Zetesis API.
+
+This is the server that lists on the Official MCP Registry and the Claude
+Connectors Directory. It holds no engine, no Anthropic key, and no signing key:
+the user sets ZETESIS_TOKEN (only for the full dossier) and every call goes to
+https://api.zetesis.science. If MCP is superseded, this file is rewritten and the
+hosted engine is untouched.
+
+Tool descriptions are written for discovery: the model reads them to decide when
+to reach for Zetesis, so they name the intents this tool should win.
+
+Config:
+  ZETESIS_TOKEN  the user's token (only for a full dossier; the free screen needs none)
+  ZETESIS_API    override the API base (default https://api.zetesis.science)
+"""
+import json
+import os
+import urllib.error
+import urllib.request
+
+from mcp.server.fastmcp import FastMCP
+
+API = os.environ.get("ZETESIS_API", "https://api.zetesis.science").rstrip("/")
+TOKEN = os.environ.get("ZETESIS_TOKEN", "")
+
+mcp = FastMCP("zetesis")
+
+# every tool here only reads / requests an evaluation; nothing mutates the user's
+# environment. openWorld because each call reaches an external service.
+_READ = {"readOnlyHint": True, "destructiveHint": False, "openWorldHint": True}
+
+
+@mcp.tool(annotations={**_READ, "title": "Evaluate a scientific or AI claim"})
+def evaluate_claim(claim: str, context: str = "", documents: str = "", depth: str = "screen", mode: str = "research") -> str:
+    """Evaluate how rigorously a scientific, biomedical, clinical, or AI/ML claim was derived, and how well the evidence supports it.
+
+    Use this whenever someone wants to assess, screen, sanity-check, or do due
+    diligence on a research claim, a study, a paper, an abstract, a preprint, a
+    grant or a pitch: whether the methodology is sound, whether the data was
+    harmonized and controlled properly, whether the statistics hold, whether the
+    result reproduces, and how well the public literature, clinical trials, and
+    filings back it. It grades each evidence dimension and returns an overall
+    reading with sources cited by hard id (PMID, DOI, NCT, NIH grant, SEC filing).
+    Works for drug, omics, target-validation, diagnostic, and AI-model claims.
+
+    A screen is free and needs no token. A full attested dossier (deep) is the
+    signed, independently re-checkable audit and needs access.
+
+    Args:
+        claim: the claim to evaluate, in one or two sentences.
+        context: optional background (stage, field, the decision at hand).
+        documents: optional source text (a deck, abstract, or paper).
+        depth: "screen" for a fast, free pass (no token needed), "deep" for the full
+            attested dossier (needs access).
+        mode: "research" (science only) or "diligence" (adds the capital reading); deep only.
+    """
+    if depth == "screen":
+        status, d = _call("POST", "/screen",
+                          {"claim": claim, "context": context, "documents": documents}, auth=False)
+        if status == 429:
+            return d.get("detail", "Free screens are used up for now.")
+        if status == 0:
+            return d.get("detail", "network error")
+        if status >= 400:
+            return f"Error: {d.get('detail', status)}"
+        return d.get("summary", "(no summary returned)")
+
+    if not TOKEN:
+        return f"A full attested dossier needs access. Request it at {API}/request-access."
+    status, d = _call("POST", "/evaluate",
+                      {"claim": claim, "context": context, "documents": documents, "depth": "deep", "mode": mode})
+    if status == 401:
+        return "Your token was rejected. Check ZETESIS_TOKEN."
+    if status == 402:
+        return f"{d.get('detail', 'This needs a paid plan.')} Manage your plan at {API}."
+    if status == 0:
+        return d.get("detail", "network error")
+    if status >= 400:
+        return f"Error: {d.get('detail', status)}"
+    jid = d.get("job_id")
+    return (f"Full evaluation started (job {jid}). It runs in the background.\n"
+            f"Call check_evaluation with job_id \"{jid}\" for the result, "
+            f"or open the dossier at {API}/d/{jid} once it is ready.")
+
+
+@mcp.tool(annotations={**_READ, "title": "Get a full dossier result"})
+def check_evaluation(job_id: str) -> str:
+    """Get the result of a full (deep) Zetesis dossier started earlier. Returns the
+    reading and the rendered dossier link once it is ready.
+
+    Args:
+        job_id: the id returned by evaluate_claim for a deep evaluation.
+    """
+    status, d = _call("GET", f"/jobs/{job_id}")
+    if status >= 400:
+        return f"Error: {d.get('detail', status)}"
+    st = d.get("status")
+    if st == "pending":
+        return "Still running. Check again in a moment."
+    if st == "error":
+        return f"The evaluation failed: {d.get('error')}"
+    return d.get("summary", "(no summary)") + f"\n\nRendered dossier: {API}{d.get('dossier_url', '')}"
+
+
+@mcp.tool(annotations={**_READ, "title": "Verify a Zetesis attestation"})
+def verify_attestation(attestation_json: str) -> str:
+    """Verify a Zetesis attestation, confirming an evaluation's claim, evidence, and
+    conclusion have not been altered since it was signed. Use when someone has a
+    Zetesis dossier or attestation and wants to independently re-check it. No
+    account needed.
+
+    Args:
+        attestation_json: the full attestation object as JSON text.
+    """
+    try:
+        att = json.loads(attestation_json)
+    except json.JSONDecodeError as e:
+        return f"Not valid JSON: {e}"
+    status, d = _call("POST", "/verify", att, auth=False)
+    if status >= 400:
+        return f"Error: {d.get('detail', status)}"
+    if not d.get("valid"):
+        return f"INVALID: {d.get('reason', 'verification failed')}"
+    v = d.get("verdict", {})
+    return (f"VALID. Attestation {str(d.get('id', ''))[:16]} signed at {d.get('created')} "
+            f"using {d.get('model')}. Overall reading: {v.get('overall')}. "
+            f"{d.get('evidence_count')} public sources pinned.")
+
+
+@mcp.tool(annotations={**_READ, "title": "Zetesis account status"})
+def account_status() -> str:
+    """Show the caller's Zetesis plan and remaining free evaluations or dossier credits."""
+    if not TOKEN:
+        return f"No ZETESIS_TOKEN set. Request access at {API}/request-access."
+    status, d = _call("GET", "/me")
+    if status >= 400:
+        return f"Error: {d.get('detail', status)}"
+    cap = d.get("screen_cap")
+    cap = "unlimited" if cap is None else cap
+    return (f"Plan: {d.get('plan')}. Screens this month: {d.get('screens_used')}/{cap}. "
+            f"Dossier credits: {d.get('dossier_balance')}.")
+
+
+def _call(method, path, body=None, auth=True):
+    headers = {"Content-Type": "application/json"}
+    if auth and TOKEN:
+        headers["Authorization"] = f"Bearer {TOKEN}"
+    data = json.dumps(body).encode() if body is not None else None
+    req = urllib.request.Request(API + path, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=175) as r:
+            return r.status, json.load(r)
+    except urllib.error.HTTPError as e:
+        try:
+            return e.code, json.load(e)
+        except Exception:
+            return e.code, {"detail": e.reason}
+    except Exception as e:  # network / timeout
+        return 0, {"detail": f"could not reach Zetesis ({type(e).__name__})"}
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()