Data Ingestion¶

# Full seed from scratch (run in order)
python -m app.seed                # Tenant, consent purposes, legal agreements
python -m app.seed_providers      # 42 providers across 8 countries
python -m app.seed_demo           # Procedures, links, demo patient
python -m app.seed_graph          # Neo4j nodes and relationships
python -m app.seed_embeddings     # Qdrant vector embeddings
python -m app.seed_doctors        # 8 doctors with Neo4j sync

async def seed_tenant():
    existing = await db.fetch_one(
        "SELECT id FROM tenants WHERE tenant_id = :tid",
        {"tid": "tenant-apollo-001"},
    )
    if existing:
        logger.info("Tenant already exists, skipping")
        return
    # Create tenant...

provider = {
    "name": "Bumrungrad International Hospital",
    "country": "Thailand",
    "city": "Bangkok",
    "tier": "premium",           # premium, standard, value
    "accreditations": ["JCI", "TEMOS"],
    "specialties": ["orthopedics", "cardiology", "oncology"],
    "bed_count": 580,
    "international_patient_center": True,
    "languages_spoken": ["en", "th", "ar", "ja"],
    "year_established": 1980,
    "website": "https://www.bumrungrad.com",
    "contact_email": "intl@bumrungrad.com",
    "description": "One of Southeast Asia's largest private hospitals...",
    "tenant_id": "tenant-apollo-001",
}

                    Provider Network Coverage

    Costa Rica (4)      Spain (5)         UAE (5)
         |                 |                |
    Mexico (5)          Turkey (6)      India (7)
                           |                |
                      South Korea (5)   Thailand (5)

    Total: 42 providers across 8 countries

ORTHO_BASE = {
    "category": "orthopedics",
    "pre_op_requirements": [
        "Complete blood count",
        "Metabolic panel",
        "Chest X-ray",
        "EKG",
        "Orthopedic surgeon clearance",
        "Physical therapy assessment",
    ],
    "post_op_milestones": [
        "Pain management protocol initiated",
        "First physical therapy session",
        "Weight-bearing assessment",
        "Discharge evaluation",
        "Follow-up imaging",
    ],
    "typical_hospital_stay_days": 3,
    "typical_recovery_weeks": 8,
}

TKR = {
    **ORTHO_BASE,
    "name": "Total Knee Replacement",
    "icd_10": "0SRD0JZ",
    "snomed_ct": "609588000",
    "pre_op_requirements": ORTHO_BASE["pre_op_requirements"] + [
        "Knee MRI",
        "Weight-bearing X-rays",
        "Bone density scan (if over 65)",
    ],
    "typical_hospital_stay_days": 2,
    "typical_recovery_weeks": 6,
}

provider_procedure_link = {
    "provider_id": provider.id,
    "procedure_id": procedure.id,
    "price_amount": 850000,      # $8,500.00 in cents
    "price_currency": "USD",
    "estimated_duration_days": 14,  # Total trip including recovery
    "success_rate_source": "hospital_reported",
    "volume_per_year": 450,
    "is_active": True,
}

demo_patient = {
    "full_name": encrypt_field("Aisha Al-Rashid"),
    "email": encrypt_field("aisha.alrashid@example.com"),
    "phone": encrypt_field("+971-50-123-4567"),
    "date_of_birth": "1985-03-15",
    "country_of_residence": "UAE",
    "preferred_language": "en",
    "timezone": "Asia/Dubai",
    "tenant_id": "tenant-apollo-001",
}

// Create Provider nodes
MERGE (p:Provider {id: $provider_id})
SET p.name = $name,
    p.city = $city,
    p.tier = $tier,
    p.bed_count = $bed_count,
    p.year_established = $year_established

// Create Country nodes and relationships
MERGE (c:Country {name: $country_name, iso_code: $iso_code})
MERGE (p)-[:LOCATED_IN]->(c)

// Create Procedure nodes and OFFERS relationships
MERGE (proc:Procedure {id: $procedure_id})
SET proc.name = $name,
    proc.category = $category,
    proc.icd_10 = $icd_10
MERGE (p)-[r:OFFERS]->(proc)
SET r.price_amount = $price,
    r.price_currency = $currency,
    r.volume_per_year = $volume

// Create Specialty nodes
MERGE (s:Specialty {name: $specialty_name})
MERGE (p)-[:SPECIALIZES_IN]->(s)

                         ┌──────────────┐
                         │   Country    │
                         │   (India)    │
                         └──────┬───────┘
                                │ LOCATED_IN
                    ┌───────────┴───────────┐
                    │                       │
              ┌─────┴──────┐         ┌──────┴─────┐
              │  Provider   │         │  Provider   │
              │  (Apollo)   │         │  (Fortis)   │
              └──┬───┬──┬──┘         └──┬───┬──────┘
                 │   │  │               │   │
    OFFERS ──────┘   │  └── SPEC_IN     │   └── OFFERS
                     │                  │
              ┌──────┴──────┐    ┌──────┴──────┐
              │  Procedure   │    │  Specialty   │
              │    (TKR)     │    │(Orthopedics) │
              └──────────────┘    └──────────────┘

from voyageai import Client as VoyageClient

voyage = VoyageClient(api_key=VOYAGE_API_KEY)

async def generate_provider_embeddings():
    """Generate and upsert provider embeddings to Qdrant."""
    providers = await db.fetch_all("SELECT * FROM providers")

    for provider in providers:
        # Compose embedding text from multiple fields
        text = f"""
        {provider['name']} is a {provider['tier']} medical facility
        located in {provider['city']}, {provider['country']}.
        Specialties: {', '.join(provider['specialties'])}.
        Accreditations: {', '.join(provider['accreditations'])}.
        {provider['description']}
        """

        # Generate embedding via Voyage AI
        embedding = voyage.embed(
            texts=[text],
            model="voyage-3.5-lite",
        ).embeddings[0]  # 1024 dimensions

        # Upsert to Qdrant
        qdrant.upsert(
            collection_name="providers",
            points=[{
                "id": str(provider["id"]),
                "vector": embedding,
                "payload": {
                    "name": provider["name"],
                    "country": provider["country"],
                    "city": provider["city"],
                    "tier": provider["tier"],
                    "specialties": provider["specialties"],
                },
            }],
        )

from qdrant_client.models import Distance, VectorParams

# Create collections with cosine similarity
for collection_name in ["providers", "conditions", "requirement_embeddings"]:
    qdrant.recreate_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(
            size=1024,              # voyage-3.5-lite dimension
            distance=Distance.COSINE,
        ),
    )

doctor = {
    "name": "Dr. Rajesh Sharma",
    "provider_id": apollo_chennai.id,
    "specialty": "Orthopedic Surgery",
    "sub_specialty": "Joint Replacement",
    "years_experience": 22,
    "education": [
        {"degree": "MBBS", "institution": "AIIMS Delhi", "year": 1998},
        {"degree": "MS Orthopedics", "institution": "AIIMS Delhi", "year": 2002},
        {"degree": "Fellowship", "institution": "HSS New York", "year": 2004},
    ],
    "board_certifications": ["National Board of Examinations (India)", "AO Trauma"],
    "languages": ["en", "hi", "ta"],
    "procedures_performed": 3500,
    "publications_count": 45,
    "verified": True,
    "verification_date": "2025-11-15",
    "profile_image_url": None,  # To be added
    "bio": "Dr. Sharma is one of India's leading joint replacement surgeons...",
    "tenant_id": "tenant-apollo-001",
}

// Create Doctor node
MERGE (d:Doctor {id: $doctor_id})
SET d.name = $name,
    d.specialty = $specialty,
    d.sub_specialty = $sub_specialty,
    d.years_experience = $years_experience,
    d.verified = $verified

// Link to Provider
MATCH (p:Provider {id: $provider_id})
MERGE (d)-[:PRACTICES_AT]->(p)

// Link to Specialty
MERGE (s:Specialty {name: $specialty})
MERGE (d)-[:SPECIALIZES_IN]->(s)

// Link to Procedures
MATCH (proc:Procedure {name: $procedure_name})
MERGE (d)-[:PERFORMS]->(proc)

    ┌────────────┐     PRACTICES_AT     ┌──────────────┐
    │   Doctor    │────────────────────>│   Provider    │
    │ (Dr.Sharma) │                     │   (Apollo)    │
    └──┬────┬────┘                     └──────────────┘
       │    │
       │    └── SPECIALIZES_IN ──> [Orthopedics]
       │
       └── PERFORMS ──> [TKR]  [THR]

language_services = {
    "interpreter_languages": ["en", "ar", "ja", "zh"],
    "coordinator_languages": ["en", "ar", "ja"],
    "document_translation_languages": ["en", "ar", "ja", "zh", "de"],
}

# Stored as JSONB on the providers table
await db.execute(
    """
    UPDATE providers SET language_services = :services
    WHERE id = :provider_id
    """,
    {"services": json.dumps(language_services), "provider_id": provider.id},
)

# PostgreSQL counts
python -c "
from app.db import get_db
db = get_db()
print('Providers:', db.execute('SELECT COUNT(*) FROM providers').scalar())
print('Procedures:', db.execute('SELECT COUNT(*) FROM procedures').scalar())
print('Links:', db.execute('SELECT COUNT(*) FROM provider_procedures').scalar())
print('Doctors:', db.execute('SELECT COUNT(*) FROM doctors').scalar())
print('Patients:', db.execute('SELECT COUNT(*) FROM patients').scalar())
"

# Neo4j counts
python -c "
from app.graph import get_driver
with get_driver().session() as s:
    for label in ['Provider','Procedure','Doctor','Country','Specialty']:
        count = s.run(f'MATCH (n:{label}) RETURN count(n)').single()[0]
        print(f'{label}: {count}')
"

# Qdrant counts
python -c "
from app.vector import get_client
client = get_client()
for name in ['providers','conditions','requirement_embeddings']:
    info = client.get_collection(name)
    print(f'{name}: {info.points_count} vectors')
"

# 1. Clear existing data (destructive!)
python -m app.clear_data          # Truncates PostgreSQL tables
python -m app.clear_graph         # Deletes all Neo4j nodes
python -m app.clear_embeddings    # Drops Qdrant collections

# 2. Re-run full seed sequence
python -m app.seed
python -m app.seed_providers
python -m app.seed_demo
python -m app.seed_graph
python -m app.seed_embeddings
python -m app.seed_doctors