AI Content Verification System

import requests
from typing import List, Dict

LEMMA_API_KEY = "your_api_key"

class ContentVerificationSystem:
    """
    Automated verification system for AI-generated medical content.
    Extracts claims and verifies against FDA sources with fingerprints.
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.lemma.la/v1"
    
    def verify_content(self, content: str) -> Dict:
        """
        Verify all medical claims in AI-generated content.
        Returns: verification report with fingerprints for audit trail.
        """
        # Step 1: Extract verifiable claims from content
        claims = self._extract_claims(content)
        
        # Step 2: Verify each claim against FDA sources
        verification_results = []
        for claim in claims:
            result = self._verify_claim(claim)
            verification_results.append(result)
        
        # Step 3: Generate verification report
        return {
            "content": content,
            "verified": all(r['verified'] for r in verification_results),
            "claims": verification_results,
            "audit_trail": self._generate_audit_trail(verification_results)
        }
    
    def _extract_claims(self, content: str) -> List[str]:
        """
        Extract factual medical claims that need verification.
        In production, use NLP to identify claims automatically.
        """
        # Simplified example - in production, use LLM or NLP
        claims = [
            "Metformin may cause lactic acidosis",
            "Risk higher in patients with kidney disease",
            "Common side effects include nausea and diarrhea"
        ]
        return claims
    
    def _verify_claim(self, claim: str) -> Dict:
        """
        Verify a single claim against FDA sources.
        Returns: verification result with fingerprint.
        """
        # Search Lemma for FDA evidence
        response = requests.post(
            f"{self.base_url}/search",
            headers={
                "x-api-key": self.api_key,
                "Content-Type": "application/json"
            },
            json={
                "question": claim,
                "top_k": 3
            }
        )
        
        response_data = response.json()
        data = response_data.get('data', response_data)
        
        if data.get('results'):
            # Found FDA evidence supporting claim
            best_match = data['results'][0]
            return {
                "claim": claim,
                "verified": True,
                "fda_source": best_match['text'],
                "fingerprint": best_match['fingerprint'],
                "drug": best_match['drug']['name'],
                "section": best_match['section'],
                "source_url": best_match['source']['url']
            }
        else:
            # No FDA evidence found - claim may be incorrect
            return {
                "claim": claim,
                "verified": False,
                "reason": "No FDA source found supporting this claim"
            }
    
    def _generate_audit_trail(self, results: List[Dict]) -> Dict:
        """
        Generate audit trail with fingerprints for regulatory compliance.
        """
        return {
            "verification_timestamp": datetime.now().isoformat(),
            "total_claims": len(results),
            "verified_claims": sum(1 for r in results if r['verified']),
            "fingerprints": [
                r['fingerprint'] for r in results if r.get('fingerprint')
            ],
            "regulatory_note": "All fingerprints can be independently verified via Lemma Verify API"
        }
    
    def publish_with_proof(self, content: str, verification: Dict) -> Dict:
        """
        Publish content with embedded verification proof.
        Store fingerprints in content metadata for audit trail.
        """
        return {
            "content_id": f"content-{hash(content)}",
            "content": content,
            "metadata": {
                "verified": verification['verified'],
                "verification_date": datetime.now().isoformat(),
                "claims": [
                    {
                        "text": claim['claim'],
                        "fingerprint": claim.get('fingerprint'),
                        "verified": claim['verified']
                    }
                    for claim in verification['claims']
                ],
                "audit_trail": verification['audit_trail']
            }
        }

# Example usage
verifier = ContentVerificationSystem(LEMMA_API_KEY)

ai_content = """
Metformin is commonly prescribed for type 2 diabetes. It may cause 
lactic acidosis, especially in patients with kidney disease. Common 
side effects include nausea, diarrhea, and stomach upset.
"""

# Verify all claims
verification = verifier.verify_content(ai_content)

if verification['verified']:
    print("✓ All claims verified against FDA sources")
    
    # Publish with cryptographic proof
    publication = verifier.publish_with_proof(ai_content, verification)
    print(f"Published with {len(publication['metadata']['claims'])} verified claims")
    print("Fingerprints stored for regulatory audit trail")
else:
    print("⚠️ Some claims could not be verified")
    for claim in verification['claims']:
        if not claim['verified']:
            print(f"  • Unverified: {claim['claim']}")