Human Expert Network

1. Application & Documentation
   ├── License verification (primary source)
   ├── Board certification check
   ├── Education verification
   └── Background check

2. Skills Assessment
   ├── Clinical knowledge test
   ├── Calibration case review
   └── Platform training

3. Ongoing Monitoring
   ├── License status monitoring
   ├── Performance tracking
   └── Annual re-credentialing

from akhara import Akhara

client = Akhara()

# View reviewer credentials for your evaluation
reviewers = client.reviewers.list(
    evaluation_id="eval_abc123",
    include_credentials=True
)

for reviewer in reviewers:
    print(f"""
Reviewer: {reviewer.id}
  Type: {reviewer.credential_type}  # e.g., "physician"
  Specialty: {reviewer.specialty}
  License State: {reviewer.license_state}
  License Status: {reviewer.license_status}
  License Verified: {reviewer.license_verified_at}
  Board Certified: {reviewer.board_certified}

  Platform Stats:
    Reviews Completed: {reviewer.total_reviews}
    Agreement Rate: {reviewer.agreement_rate:.1%}
    Avg Review Time: {reviewer.avg_review_time_seconds:.0f}s
""")

# Configure custom assignment rules
client.evaluations.configure_assignment(
    evaluation_id="eval_abc123",

    assignment={
        "mode": "auto",  # auto, manual, hybrid

        # Require specific credentials
        "require_credentials": ["physician"],

        # Prefer certain specialties
        "prefer_specialties": ["emergency_medicine", "internal_medicine"],

        # Exclude reviewers with conflicts
        "exclude_organizations": ["competitor_health_system"],

        # Geographic requirements (for state-specific regulations)
        "require_state_license": ["CA", "NY", "TX"]
    }
)

# Configure conflict-of-interest rules
client.organizations.configure_coi(
    # Organizations that cannot review your AI
    excluded_organizations=[
        "my_company",  # Internal employees
        "competitor_a",
        "competitor_b"
    ],

    # Require conflict disclosure
    require_disclosure=True,

    # Blind reviewers to AI source
    blind_ai_source=True,

    # Prevent same reviewer from seeing related cases
    prevent_case_clustering=True
)

# Monitor reviewer performance
qa_dashboard = client.reviewers.quality_dashboard()

print(f"""
Network Quality Metrics
=======================
Active Reviewers: {qa_dashboard.active_reviewers}
Avg Inter-rater Reliability (κ): {qa_dashboard.avg_kappa:.2f}
Avg Agreement Rate: {qa_dashboard.avg_agreement:.1%}

Performance Distribution:
  Excellent (>95%): {qa_dashboard.excellent_count} reviewers
  Good (85-95%): {qa_dashboard.good_count} reviewers
  Needs Improvement (70-85%): {qa_dashboard.needs_improvement_count} reviewers
  Under Review (<70%): {qa_dashboard.under_review_count} reviewers

Recent Alerts:
""")

for alert in qa_dashboard.recent_alerts:
    print(f"  ⚠️ {alert.reviewer_id}: {alert.reason}")

# Register internal reviewers
internal_reviewer = client.reviewers.register(
    email="[email protected]",

    credentials={
        "type": "physician",
        "specialty": "internal_medicine",
        "license_number": "A123456",
        "license_state": "CA",
        "npi": "1234567890"
    },

    # Organization context
    organization="my_org",
    internal=True,

    # Skip external verification (you vouch for them)
    skip_verification=True,

    # Restrict to your evaluations only
    restrict_to_org=True
)

# Create internal-only evaluation
evaluation = client.evaluations.create(
    name="Internal QA Review",
    dataset="ds_production",
    evaluators=[...],

    human_review={
        "enabled": True,
        "reviewer_source": "internal_only",  # Only use your reviewers
        "reviewer_pool": "my_org"
    }
)