Python SDK

pip install glyphnet

from glyphnet import GlyphNet
 
# Initialize client
client = GlyphNet(api_key="gn_live_...")
 
# Verify text
result = client.verify("The Earth orbits the Sun")
 
print(f"Verified: {result.verified}")
print(f"Confidence: {result.confidence}")

export GLYPHNET_API_KEY="gn_live_..."

from glyphnet import GlyphNet
 
# Automatically uses GLYPHNET_API_KEY
client = GlyphNet()

from glyphnet import GlyphNet
 
client = GlyphNet(
    api_key="gn_live_...",           # Required (or use env var)
    base_url="https://api.glyphnet.io",  # Optional
    timeout=30.0,                     # Timeout in seconds
    max_retries=3,                    # Retry failed requests
    retry_delay=1.0,                  # Initial retry delay
)

result = client.verify("Paris is the capital of France")
 
print(result.verified)        # True
print(result.confidence)      # 0.98
print(result.claims)          # List of claim objects

# Flagging mode (default) - returns results with warnings
result = client.verify(text, mode="flagging")
 
# Blocking mode - raises exception if unverified
result = client.verify(text, mode="blocking")
 
# Logging mode - always succeeds, logs for monitoring
result = client.verify(text, mode="logging")

# Custom confidence threshold
result = client.verify(text, threshold=0.8)

result = client.verify(text)
 
# Properties
result.request_id       # Unique request identifier
result.text             # Original input text
result.flagged          # True if any claims unverified
result.claims           # List of Claim objects
result.summary          # Summary statistics
result.processing_time  # Processing time in ms
 
# Summary properties
result.summary.total_claims     # Number of claims found
result.summary.verified         # Number verified
result.summary.unverified       # Number unverified
result.summary.avg_confidence   # Average confidence score

for claim in result.claims:
    print(claim.text)        # Claim text
    print(claim.verified)    # True/False
    print(claim.confidence)  # 0.0 - 1.0
    print(claim.sources)     # Supporting sources (optional)

import asyncio
from glyphnet import AsyncGlyphNet
 
async def main():
    client = AsyncGlyphNet(api_key="gn_live_...")
 
    # Single verification
    result = await client.verify("The Earth orbits the Sun")
 
    # Batch verification
    texts = ["Claim 1", "Claim 2", "Claim 3"]
    results = await asyncio.gather(*[
        client.verify(text) for text in texts
    ])
 
    await client.close()
 
asyncio.run(main())

async with AsyncGlyphNet() as client:
    result = await client.verify(text)
    # Client automatically closed

from glyphnet import GlyphNet
from glyphnet.errors import (
    GlyphNetError,
    AuthenticationError,
    RateLimitError,
    QuotaExceededError,
    ValidationError,
    APIError,
    NetworkError,
)
 
client = GlyphNet()
 
try:
    result = client.verify(text)
except AuthenticationError:
    print("Invalid or missing API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
except QuotaExceededError as e:
    print(f"Quota exceeded. Resets at {e.resets_at}")
except ValidationError as e:
    print(f"Invalid request: {e.message}")
    print(f"Field: {e.field}")
except NetworkError as e:
    print(f"Network error: {e.message}")
except APIError as e:
    print(f"API error {e.status_code}: {e.message}")
except GlyphNetError as e:
    print(f"GlyphNet error: {e}")

# Check for harmful content
harm_result = client.harm_detect(text)
 
print(harm_result.harmful)      # True if harmful detected
print(harm_result.categories)   # List of detected categories
print(harm_result.severity)     # "low", "medium", "high"
 
# Categories
for category in harm_result.categories:
    print(category.name)        # e.g., "hate_speech"
    print(category.confidence)  # 0.0 - 1.0

# List all keys
keys = client.keys.list()
for key in keys:
    print(f"{key.name}: {key.prefix}... (created {key.created_at})")
 
# Create a new key
new_key = client.keys.create(name="Production Key")
print(f"New key: {new_key.api_key}")  # Only shown once!
 
# Revoke a key
client.keys.revoke(key_id="key_abc123")

usage = client.usage.get()
 
print(f"Used: {usage.current_usage}")
print(f"Limit: {usage.monthly_limit}")
print(f"Remaining: {usage.remaining}")
print(f"Percentage: {usage.percentage_used}%")
print(f"Resets: {usage.resets_at}")
 
# Rate limit info
print(f"Requests this minute: {usage.rate_limit.current_minute_usage}")
print(f"Per-minute limit: {usage.rate_limit.requests_per_minute}")

from glyphnet import GlyphNet
 
client = GlyphNet()
 
# Process multiple texts efficiently
texts = [
    "The Earth is round.",
    "Water boils at 100°C.",
    "The speed of light is constant.",
]
 
# Sequential processing
results = [client.verify(text) for text in texts]
 
# Or combine for single request
combined = " ".join(texts)
result = client.verify(combined)

import asyncio
from glyphnet import AsyncGlyphNet
 
async def batch_verify(texts: list[str], max_concurrent: int = 10):
    semaphore = asyncio.Semaphore(max_concurrent)
 
    async def verify_one(client, text):
        async with semaphore:
            return await client.verify(text)
 
    async with AsyncGlyphNet() as client:
        tasks = [verify_one(client, text) for text in texts]
        return await asyncio.gather(*tasks)
 
results = asyncio.run(batch_verify(texts))

from glyphnet import GlyphNet
from glyphnet.retry import RetryConfig
 
client = GlyphNet(
    retry_config=RetryConfig(
        max_retries=3,
        initial_delay=1.0,
        max_delay=60.0,
        exponential_base=2.0,
        retry_on=[429, 500, 502, 503, 504],
    )
)

import logging
 
# Enable debug logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("glyphnet")
logger.setLevel(logging.DEBUG)
 
client = GlyphNet()
result = client.verify(text)  # Logs request/response details

from glyphnet import GlyphNet
from glyphnet.types import VerificationResult, Claim, VerificationMode
 
client: GlyphNet = GlyphNet()
 
result: VerificationResult = client.verify(
    text="Example text",
    mode=VerificationMode.FLAGGING,
)
 
claim: Claim
for claim in result.claims:
    confidence: float = claim.confidence

from langchain.llms import OpenAI
from glyphnet import GlyphNet
 
llm = OpenAI()
verifier = GlyphNet()
 
def verified_generate(prompt: str) -> str:
    response = llm(prompt)
    result = verifier.verify(response)
 
    if result.flagged:
        unverified = [c.text for c in result.claims if not c.verified]
        return f"{response}\n\n⚠️ Unverified: {unverified}"
 
    return response

from fastapi import FastAPI, HTTPException
from glyphnet import GlyphNet
from glyphnet.errors import GlyphNetError
 
app = FastAPI()
client = GlyphNet()
 
@app.post("/verify")
async def verify_text(text: str):
    try:
        result = client.verify(text)
        return result.to_dict()
    except GlyphNetError as e:
        raise HTTPException(status_code=500, detail=str(e))