Python SDK

pip install qwed

from qwed_sdk import QWEDClient

client = QWEDClient(api_key="qwed_your_key")

# Basic verification
result = client.verify("Is 2+2=4?")
print(result.verified)  # True
print(result.status)    # "VERIFIED"

from qwed_sdk import QWEDAsyncClient
import asyncio

async def main():
    async with QWEDAsyncClient(api_key="qwed_...") as client:
        result = await client.verify("2+2=4")
        print(result.verified)

asyncio.run(main())

result = client.verify("What is 15% of 200?")

result = client.verify_math("x**2 + 2*x + 1 = (x+1)**2")

result = client.verify_logic("(AND (GT x 5) (LT y 10))")
print(result.model)  # {"x": 6, "y": 9}

result = client.verify_code(code, language="python")
for vuln in result.vulnerabilities:
    print(f"{vuln.severity}: {vuln.message}")

result = client.verify_sql(
    query="SELECT * FROM users WHERE id = 1",
    schema_ddl="CREATE TABLE users (id INT, name TEXT)",
    dialect="postgresql"
)

result = client.verify_fact(
    claim="The company was founded in 2020",
    context="Acme Corp was established in 2020 in San Francisco."
)
print(result.verified)  # True

result = client.verify_stats(
    query="The average salary is above 50000",
    file_path="data.csv"
)

result = client.verify_consensus(
    query="The square root of 144 is 12",
    mode="high",
    min_confidence=0.8
)
print(result.verified)     # True
print(result.confidence)   # 0.95

result = client.verify_image(
    image_path="photo.jpg",
    claim="This image contains a cat"
)

response = client.verify_batch([
    {"query": "2+2=4", "type": "math"},
    {"query": "x + x", "type": "math"},
])

for item in response.items:
    result = item.result or {}
    if result.get("status") == "VERIFIED" and result.get("proof_ref"):
        # Authoritative — admissible for control flow
        print("verified:", result.get("agent_message"), result.get("proof_ref"))
    else:
        # UNVERIFIABLE or BLOCKED — must reject
        print("rejected:", result.get("status"), result.get("agent_message"))

document = client.create_verification_context_from_diagnostic(
    diagnostic={
        "status": "VERIFIED",
        "agent_message": "Identity verified",
        "developer_fields": {"is_valid": True},
        "proof_ref": "sha256:9f2c…",
    },
    query="x**2 + 2*x + 1 = (x+1)**2",
    verifier="MathVerifier",
    attestation_token=token,
)
print(document["verdict"])                             # "VERIFIED"
print(document["context"]["decision"]["admission"])    # "ADMIT"

result = client.validate_verification_context(document)
print(result["valid"])  # True or False

result = client.resolve_verification_context(document)
print(result["resolved"])  # True only if the stored proof_ref matches

from qwed_sdk import (
    # Enums and model types
    Verdict,
    Admission,
    VerificationContext,
    VerificationContextDocument,
    VerificationContextValidationError,
    Formalization,
    VerifiedObject,
    Interpretation,
    Proof,
    Evidence,
    Decision,
    # proof_ref helpers
    compute_document_proof_ref,
    resolve_document_proof_ref,
    compute_context_proof_ref,
    resolve_context_proof_ref,
    # Schema validation helpers
    validate_document,
    is_valid_document,
)

# Validate a document dict (raises VerificationContextValidationError on failure)
validate_document(document)

# Boolean variant
if is_valid_document(document):
    ...

# Recompute and check the evidence commitment locally
assert resolve_document_proof_ref(document)

document = verifier.to_verification_context(result, query="x**2 + 2*x + 1 = (x+1)**2")
document.validate()
print(document.to_dict()["verdict"])

from qwed_sdk.cache import CacheContext, VerificationCache

cache = VerificationCache()  # defaults to ~/.qwed/cache, TTL 24h

ctx = CacheContext(
    provider="openai",
    model="gpt-4o",
    policy_version="v1",
    tenant_id="tenant-alpha",
)

# Cache miss on first call
result = cache.get("Is 2+2=4?", ctx)         # None

# Populate the cache for this (query, context) pair
cache.set("Is 2+2=4?", {"verified": True, "value": 4}, ctx)

# Same query, same context → hit
cache.get("Is 2+2=4?", ctx)                  # {"verified": True, "value": 4}

# Same query, different provider → deterministic miss
ctx_other = CacheContext(provider="anthropic", model="claude-opus-4-5", policy_version="v1")
cache.get("Is 2+2=4?", ctx_other)            # None

VerificationCache(cache_dir: Optional[str] = None, ttl: int = 86400)

# Verify
qwed verify "2+2=4"

# Verify logic
qwed verify-logic "(AND (GT x 5) (LT y 10))"

# Verify code file
qwed verify-code -f script.py

# Batch verify
qwed batch -f queries.json

# Verification Context v1.0 utilities (v7.1.0)
qwed context validate document.json
qwed context resolve document.json
qwed context from-diagnostic --diagnostic-file diag.json \
  --query "x + x = 2*x" --verifier MathVerifier

from qwed_sdk.cache import CacheContext, VerificationCache

ctx = CacheContext(
    provider="openai",
    model="gpt-4o",
    policy_version="v1",
    tenant_id="tenant-alpha",       # optional
    env_fingerprint="sha256-...",   # optional
)

cache = VerificationCache()

cache.get("2+2", ctx)              # None (miss)
cache.set("2+2", {"verified": True}, ctx)
cache.get("2+2", ctx)              # {"verified": True}

# Different provider — deterministic miss (replay prevention)
ctx2 = CacheContext(provider="claude", model="claude-opus-4-5", policy_version="v1")
cache.get("2+2", ctx2)             # None

from qwed_sdk.guards import (
    RAGGuard,
    ExfiltrationGuard,
    MCPPoisonGuard,
    SelfInitiatedCoTGuard,
    SovereigntyGuard,
    SystemGuard,
    ConfigGuard,
)

# Prevent RAG hallucinations from wrong document chunks
rag_guard = RAGGuard(max_drm_rate="1/10")
result = rag_guard.verify_retrieval_context(
    target_document_id="contract_v2",
    retrieved_chunks=chunks
)

# Block data exfiltration to unauthorized endpoints
exfil_guard = ExfiltrationGuard(allowed_endpoints=["https://api.openai.com"])
result = exfil_guard.verify_outbound_call(
    destination_url=url,
    payload=data
)

# Detect poisoned MCP tool definitions
mcp_guard = MCPPoisonGuard()
result = mcp_guard.verify_tool_definition(tool_schema)

# Block dangerous shell commands (v4.0.0)
sys_guard = SystemGuard()
result = sys_guard.verify_shell_command("rm -rf /")

# Detect plaintext secrets in config (v4.0.0)
cfg_guard = ConfigGuard()
result = cfg_guard.verify_config_safety(config_data)