trustandverify 0.1.0__tar.gz

trustandverify-0.1.0/LICENSE

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

trustandverify-0.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: trustandverify
+Version: 0.1.0
+Summary: Agentic knowledge verification using Subjective Logic confidence algebra
+License: MIT
+License-File: LICENSE
+Keywords: knowledge-verification,subjective-logic,confidence-algebra,agentic-ai,hallucination-detection,provenance,json-ld,uncertainty-quantification,fact-checking
+Author: Muntaser Syed
+Author-email: jemsbhai@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Provides-Extra: all
+Provides-Extra: anthropic
+Provides-Extra: bing
+Provides-Extra: brave
+Provides-Extra: cli
+Provides-Extra: gemini
+Provides-Extra: mongo
+Provides-Extra: neo4j
+Provides-Extra: ollama
+Provides-Extra: openai
+Provides-Extra: pdf
+Provides-Extra: postgres
+Provides-Extra: redis
+Provides-Extra: serpapi
+Provides-Extra: sqlite
+Provides-Extra: tavily
+Provides-Extra: ui
+Requires-Dist: anthropic (>=0.25) ; extra == "anthropic" or extra == "all"
+Requires-Dist: asyncpg (>=0.28) ; extra == "postgres" or extra == "all"
+Requires-Dist: httpx (>=0.24)
+Requires-Dist: jsonld-ex (>=0.6)
+Requires-Dist: litellm (>=1.0) ; extra == "gemini" or extra == "all"
+Requires-Dist: motor (>=3.0) ; extra == "mongo" or extra == "all"
+Requires-Dist: neo4j (>=5.0) ; extra == "neo4j" or extra == "all"
+Requires-Dist: ollama (>=0.1) ; extra == "ollama" or extra == "all"
+Requires-Dist: openai (>=1.0) ; extra == "openai" or extra == "all"
+Requires-Dist: redis (>=5.0) ; extra == "redis" or extra == "all"
+Requires-Dist: rich (>=13.0) ; extra == "cli" or extra == "all"
+Requires-Dist: streamlit (>=1.30) ; extra == "ui" or extra == "all"
+Requires-Dist: tavily-python (>=0.3) ; extra == "tavily" or extra == "all"
+Requires-Dist: typer (>=0.9) ; extra == "cli" or extra == "all"
+Requires-Dist: weasyprint (>=60) ; extra == "pdf" or extra == "all"
+Project-URL: Documentation, https://github.com/jemsbhai/trustandverify#readme
+Project-URL: Homepage, https://github.com/jemsbhai/trustandverify
+Project-URL: Repository, https://github.com/jemsbhai/trustandverify
+Description-Content-Type: text/markdown
+
+# 🔍 trustandverify
+
+[![PyPI](https://img.shields.io/pypi/v/trustandverify)](https://pypi.org/project/trustandverify/)
+[![Python](https://img.shields.io/pypi/pyversions/trustandverify)](https://pypi.org/project/trustandverify/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Tests](https://github.com/jemsbhai/trustandverify/actions/workflows/ci.yml/badge.svg)](https://github.com/jemsbhai/trustandverify/actions)
+
+**Agentic knowledge verification using Subjective Logic confidence algebra.**
+
+`trustandverify` decomposes research questions into verifiable claims, gathers evidence from multiple search backends, scores confidence using formal Subjective Logic mathematics (Jøsang 2016), and produces provenance-rich reports with per-claim uncertainty quantification.
+
+---
+
+## The Problem
+
+Every major AI system treats confidence as a single scalar — or ignores it entirely. A `confidence = 0.5` is meaningless: it could mean "strong evidence that the probability is 50%", or "we have literally no evidence and are guessing." These require fundamentally different downstream decisions.
+
+`trustandverify` uses **Subjective Logic opinion tuples** `(belief, disbelief, uncertainty, base_rate)` so you always know *not just what the AI thinks, but how much evidence it has.*
+
+---
+
+## Quick Start
+
+```bash
+pip install trustandverify[tavily,gemini]
+```
+
+```python
+import asyncio
+from trustandverify import verify
+
+report = asyncio.run(verify("Is remote work more productive than office work?"))
+print(report.summary)
+for claim in report.claims:
+    op = claim.opinion
+    print(f"  [{claim.verdict}] {claim.text}")
+    print(f"    P={op.projected_probability():.3f}  b={op.belief:.3f} d={op.disbelief:.3f} u={op.uncertainty:.3f}")
+```
+
+---
+
+## Configured Usage
+
+```python
+from trustandverify import TrustAgent, TrustConfig
+from trustandverify.search import TavilySearch
+from trustandverify.llm import GeminiBackend
+from trustandverify.storage import SQLiteStorage
+from trustandverify.export import JsonLdExporter, MarkdownExporter
+
+config = TrustConfig(num_claims=5, max_sources_per_claim=3)
+
+agent = TrustAgent(
+    config=config,
+    search=TavilySearch(),
+    llm=GeminiBackend(),
+    storage=SQLiteStorage("reports.db"),
+)
+
+report = await agent.verify("Is nuclear energy safer than solar?")
+
+JsonLdExporter().render_to_file(report, "report.jsonld")
+MarkdownExporter().render_to_file(report, "report.md")
+```
+
+---
+
+## CLI
+
+```bash
+trustandverify "Is coffee healthy?"
+trustandverify "Is coffee healthy?" --claims 5 --llm gemini --format markdown
+trustandverify ui   # Launch Streamlit dashboard
+```
+
+---
+
+## Why Subjective Logic?
+
+| Scenario | Scalar Confidence | `trustandverify` Opinion |
+|---|---|---|
+| Strong evidence it's 50/50 | 0.5 | `b=0.45, d=0.45, u=0.10` |
+| No evidence at all | 0.5 | `b=0.00, d=0.00, u=1.00` |
+| Sources violently disagree | 0.5 | `b=0.40, d=0.40, u=0.20` |
+
+Confidence algebra (from [`jsonld-ex`](https://pypi.org/project/jsonld-ex/)):
+- **Cumulative fusion** — more independent agreeing sources → lower uncertainty
+- **Trust discount** — `.gov`/`.edu` sources weighted higher than Reddit
+- **Pairwise conflict detection** — surfaces where sources disagree, quantified
+
+---
+
+## Install Options
+
+```bash
+pip install trustandverify                              # core only
+pip install trustandverify[tavily,gemini]               # minimal working setup
+pip install trustandverify[tavily,brave,openai,sqlite]  # typical setup
+pip install trustandverify[all]                         # everything
+```
+
+---
+
+## Architecture
+
+```
+trustandverify/
+├── core/        — TrustAgent, pipeline, models, config
+├── scoring/     — Subjective Logic algebra (wraps jsonld-ex)
+├── search/      — SearchBackend protocol + Tavily, Brave, Bing, SerpAPI
+├── llm/         — LLMBackend protocol + Gemini, OpenAI, Anthropic, Ollama
+├── storage/     — StorageBackend protocol + memory, SQLite, Postgres, Neo4j
+├── cache/       — CacheBackend protocol + file cache, Redis
+├── export/      — ExportBackend protocol + JSON-LD, Markdown, HTML, PDF
+├── cli/         — Typer CLI
+└── ui/          — Streamlit dashboard
+```
+
+---
+
+## References
+
+- Jøsang, A. (2016). *Subjective Logic: A Formalism for Reasoning Under Uncertainty.* Springer.
+- [`jsonld-ex`](https://pypi.org/project/jsonld-ex/) — JSON-LD 1.2 extensions with Subjective Logic confidence algebra
+- W3C [PROV-O](https://www.w3.org/TR/prov-o/) — Provenance Ontology
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+

trustandverify-0.1.0/README.md

@@ -0,0 +1,131 @@
+# 🔍 trustandverify
+
+[![PyPI](https://img.shields.io/pypi/v/trustandverify)](https://pypi.org/project/trustandverify/)
+[![Python](https://img.shields.io/pypi/pyversions/trustandverify)](https://pypi.org/project/trustandverify/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Tests](https://github.com/jemsbhai/trustandverify/actions/workflows/ci.yml/badge.svg)](https://github.com/jemsbhai/trustandverify/actions)
+
+**Agentic knowledge verification using Subjective Logic confidence algebra.**
+
+`trustandverify` decomposes research questions into verifiable claims, gathers evidence from multiple search backends, scores confidence using formal Subjective Logic mathematics (Jøsang 2016), and produces provenance-rich reports with per-claim uncertainty quantification.
+
+---
+
+## The Problem
+
+Every major AI system treats confidence as a single scalar — or ignores it entirely. A `confidence = 0.5` is meaningless: it could mean "strong evidence that the probability is 50%", or "we have literally no evidence and are guessing." These require fundamentally different downstream decisions.
+
+`trustandverify` uses **Subjective Logic opinion tuples** `(belief, disbelief, uncertainty, base_rate)` so you always know *not just what the AI thinks, but how much evidence it has.*
+
+---
+
+## Quick Start
+
+```bash
+pip install trustandverify[tavily,gemini]
+```
+
+```python
+import asyncio
+from trustandverify import verify
+
+report = asyncio.run(verify("Is remote work more productive than office work?"))
+print(report.summary)
+for claim in report.claims:
+    op = claim.opinion
+    print(f"  [{claim.verdict}] {claim.text}")
+    print(f"    P={op.projected_probability():.3f}  b={op.belief:.3f} d={op.disbelief:.3f} u={op.uncertainty:.3f}")
+```
+
+---
+
+## Configured Usage
+
+```python
+from trustandverify import TrustAgent, TrustConfig
+from trustandverify.search import TavilySearch
+from trustandverify.llm import GeminiBackend
+from trustandverify.storage import SQLiteStorage
+from trustandverify.export import JsonLdExporter, MarkdownExporter
+
+config = TrustConfig(num_claims=5, max_sources_per_claim=3)
+
+agent = TrustAgent(
+    config=config,
+    search=TavilySearch(),
+    llm=GeminiBackend(),
+    storage=SQLiteStorage("reports.db"),
+)
+
+report = await agent.verify("Is nuclear energy safer than solar?")
+
+JsonLdExporter().render_to_file(report, "report.jsonld")
+MarkdownExporter().render_to_file(report, "report.md")
+```
+
+---
+
+## CLI
+
+```bash
+trustandverify "Is coffee healthy?"
+trustandverify "Is coffee healthy?" --claims 5 --llm gemini --format markdown
+trustandverify ui   # Launch Streamlit dashboard
+```
+
+---
+
+## Why Subjective Logic?
+
+| Scenario | Scalar Confidence | `trustandverify` Opinion |
+|---|---|---|
+| Strong evidence it's 50/50 | 0.5 | `b=0.45, d=0.45, u=0.10` |
+| No evidence at all | 0.5 | `b=0.00, d=0.00, u=1.00` |
+| Sources violently disagree | 0.5 | `b=0.40, d=0.40, u=0.20` |
+
+Confidence algebra (from [`jsonld-ex`](https://pypi.org/project/jsonld-ex/)):
+- **Cumulative fusion** — more independent agreeing sources → lower uncertainty
+- **Trust discount** — `.gov`/`.edu` sources weighted higher than Reddit
+- **Pairwise conflict detection** — surfaces where sources disagree, quantified
+
+---
+
+## Install Options
+
+```bash
+pip install trustandverify                              # core only
+pip install trustandverify[tavily,gemini]               # minimal working setup
+pip install trustandverify[tavily,brave,openai,sqlite]  # typical setup
+pip install trustandverify[all]                         # everything
+```
+
+---
+
+## Architecture
+
+```
+trustandverify/
+├── core/        — TrustAgent, pipeline, models, config
+├── scoring/     — Subjective Logic algebra (wraps jsonld-ex)
+├── search/      — SearchBackend protocol + Tavily, Brave, Bing, SerpAPI
+├── llm/         — LLMBackend protocol + Gemini, OpenAI, Anthropic, Ollama
+├── storage/     — StorageBackend protocol + memory, SQLite, Postgres, Neo4j
+├── cache/       — CacheBackend protocol + file cache, Redis
+├── export/      — ExportBackend protocol + JSON-LD, Markdown, HTML, PDF
+├── cli/         — Typer CLI
+└── ui/          — Streamlit dashboard
+```
+
+---
+
+## References
+
+- Jøsang, A. (2016). *Subjective Logic: A Formalism for Reasoning Under Uncertainty.* Springer.
+- [`jsonld-ex`](https://pypi.org/project/jsonld-ex/) — JSON-LD 1.2 extensions with Subjective Logic confidence algebra
+- W3C [PROV-O](https://www.w3.org/TR/prov-o/) — Provenance Ontology
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

trustandverify-0.1.0/pyproject.toml

@@ -0,0 +1,127 @@
+[tool.poetry]
+name = "trustandverify"
+version = "0.1.0"
+description = "Agentic knowledge verification using Subjective Logic confidence algebra"
+authors = ["Muntaser Syed <jemsbhai@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/jemsbhai/trustandverify"
+repository = "https://github.com/jemsbhai/trustandverify"
+documentation = "https://github.com/jemsbhai/trustandverify#readme"
+keywords = [
+    "knowledge-verification", "subjective-logic", "confidence-algebra",
+    "agentic-ai", "hallucination-detection", "provenance", "json-ld",
+    "uncertainty-quantification", "fact-checking",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+packages = [{include = "trustandverify", from = "src"}]
+
+# ── Core dependencies (always installed) ──────────────────────────────────────
+[tool.poetry.dependencies]
+python = "^3.10"
+jsonld-ex = ">=0.6"          # Subjective Logic confidence algebra
+httpx = ">=0.24"             # Async HTTP client for search backends
+
+# ── Optional extras ───────────────────────────────────────────────────────────
+# Search backends
+tavily-python = {version = ">=0.3", optional = true}
+
+# LLM backends
+openai    = {version = ">=1.0",  optional = true}
+anthropic = {version = ">=0.25", optional = true}
+litellm   = {version = ">=1.0",  optional = true}   # gemini + many others
+ollama    = {version = ">=0.1",  optional = true}
+
+# Storage backends
+asyncpg   = {version = ">=0.28", optional = true}    # postgres
+neo4j     = {version = ">=5.0",  optional = true}
+motor     = {version = ">=3.0",  optional = true}    # mongodb async
+redis     = {version = ">=5.0",  optional = true}
+
+# Export
+weasyprint = {version = ">=60",  optional = true}    # pdf
+
+# CLI
+typer = {version = ">=0.9",  optional = true}
+rich  = {version = ">=13.0", optional = true}
+
+# UI
+streamlit = {version = ">=1.30", optional = true}
+
+[tool.poetry.extras]
+tavily    = ["tavily-python"]
+serpapi   = []                   # uses httpx directly
+brave     = []                   # uses httpx directly
+bing      = []                   # uses httpx directly
+openai    = ["openai"]
+anthropic = ["anthropic"]
+gemini    = ["litellm"]
+ollama    = ["ollama"]
+sqlite    = []                   # stdlib, no extra dep
+postgres  = ["asyncpg"]
+neo4j     = ["neo4j"]
+mongo     = ["motor"]
+redis     = ["redis"]
+ui        = ["streamlit"]
+cli       = ["typer", "rich"]
+pdf       = ["weasyprint"]
+all       = [
+    "tavily-python", "openai", "anthropic", "litellm", "ollama",
+    "asyncpg", "neo4j", "motor", "redis",
+    "weasyprint", "typer", "rich", "streamlit",
+]
+
+# ── Dev dependencies ───────────────────────────────────────────────────────────
+[tool.poetry.group.dev.dependencies]
+pytest         = "^8.0"
+pytest-asyncio = "^0.24"
+pytest-cov     = "^6.0"
+ruff           = ">=0.2"
+mypy           = ">=1.8"
+
+# ── Entry points ───────────────────────────────────────────────────────────────
+[tool.poetry.scripts]
+trustandverify = "trustandverify.cli.main:main"
+
+# ── Build ──────────────────────────────────────────────────────────────────────
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+# ── Pytest ─────────────────────────────────────────────────────────────────────
+[tool.pytest.ini_options]
+testpaths    = ["tests"]
+asyncio_mode = "auto"
+markers = [
+    "integration: requires external API keys or services",
+    "slow: takes more than 5 seconds",
+]
+
+# ── Ruff ───────────────────────────────────────────────────────────────────────
+[tool.ruff]
+target-version = "py310"
+line-length    = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+# ── Mypy ───────────────────────────────────────────────────────────────────────
+[tool.mypy]
+python_version         = "3.10"
+strict                 = true
+ignore_missing_imports = true

trustandverify-0.1.0/src/trustandverify/__init__.py

@@ -0,0 +1,68 @@
+"""trustandverify — Agentic knowledge verification using Subjective Logic.
+
+Quick start::
+
+    import asyncio
+    from trustandverify import verify
+
+    report = asyncio.run(verify("Is remote work more productive than office work?"))
+    print(report.summary)
+    for claim in report.claims:
+        print(f"  [{claim.verdict}] {claim.text}")
+        print(f"    P={claim.opinion.projected_probability():.3f}")
+"""
+
+from __future__ import annotations
+
+from trustandverify._version import __version__
+from trustandverify.core.agent import TrustAgent
+from trustandverify.core.config import TrustConfig
+from trustandverify.core.models import Claim, Conflict, Evidence, Report, Source, Verdict
+
+
+async def verify(
+    query: str,
+    *,
+    num_claims: int = 0,
+    verbose: bool = False,
+) -> Report:
+    """One-liner verification using auto-configured backends from env vars.
+
+    Requires ``GEMINI_API_KEY`` and ``TAVILY_API_KEY`` environment variables.
+
+    Args:
+        query:      The research question or claim to verify.
+        num_claims: Number of claims to decompose into (0 = LLM decides).
+        verbose:    Print step-by-step progress to stdout.
+
+    Returns:
+        A fully populated Report.
+
+    Example::
+
+        import asyncio
+        report = asyncio.run(verify("Is coffee healthy?"))
+    """
+    from trustandverify.llm.gemini import GeminiBackend
+    from trustandverify.search.tavily import TavilySearch
+
+    agent = TrustAgent(
+        config=TrustConfig(num_claims=num_claims),
+        search=TavilySearch(),
+        llm=GeminiBackend(),
+    )
+    return await agent.verify(query, verbose=verbose)
+
+
+__all__ = [
+    "__version__",
+    "verify",
+    "TrustAgent",
+    "TrustConfig",
+    "Report",
+    "Claim",
+    "Conflict",
+    "Evidence",
+    "Source",
+    "Verdict",
+]

trustandverify-0.1.0/src/trustandverify/_version.py

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

trustandverify-0.1.0/src/trustandverify/cache/__init__.py

@@ -0,0 +1,6 @@
+"""trustandverify.cache — public exports."""
+
+from trustandverify.cache.file_cache import FileCache
+from trustandverify.cache.protocol import CacheBackend
+
+__all__ = ["CacheBackend", "FileCache"]

trustandverify-0.1.0/src/trustandverify/cache/protocol.py

@@ -0,0 +1,41 @@
+"""CacheBackend protocol — caching layer for search results and LLM responses."""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class CacheBackend(Protocol):
+    """Structural protocol for cache providers.
+
+    The cache sits between the agent and the search/LLM backends.
+    Same query + same backend = cached result. Configurable TTL.
+    Saves API quota and speeds up repeated demos.
+    """
+
+    async def get(self, key: str) -> Any | None:
+        """Retrieve a cached value, or None if missing/expired.
+
+        Args:
+            key: Cache key.
+
+        Returns:
+            The cached value, or None.
+        """
+        ...
+
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> None:
+        """Store a value in the cache.
+
+        Args:
+            key:   Cache key.
+            value: Value to store (must be JSON-serialisable for
+                   file/Redis backends).
+            ttl:   Time-to-live in seconds.  None = use backend default.
+        """
+        ...
+
+    async def invalidate(self, key: str) -> None:
+        """Remove a specific key from the cache."""
+        ...