trying to deploy

.dockerignore

@@ -0,0 +1,45 @@
+# Python caches & venvs
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.env
+.venv/
+venv/
+avenv/
+
+# Tests & coverage
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Git
+.git/
+.gitignore
+
+# Node
+node_modules/
+
+# AI / large assets
+models/
+datasets/
+*.bin
+*.pt
+*.onnx
+*.ckpt
+
+# Logs
+*.log
+
+# IDE / OS
+.DS_Store
+.vscode/
+.idea/
+*.swp
+*.swo

.gitignore

@@ -0,0 +1,74 @@
+# =========================
+# Environment variables
+# =========================
+.env
+.env.*
+!.env.example
+
+# =========================
+# Python
+# =========================
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.log
+
+# =========================
+# Virtual environments
+# =========================
+venv/
+env/
+avenv/
+.venv/
+
+# =========================
+# OS files
+# =========================
+.DS_Store
+Thumbs.db
+
+# =========================
+# Editor / IDE
+# =========================
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# =========================
+# Docker
+# =========================
+docker-compose.override.yml
+
+# =========================
+# Database / Local state
+# =========================
+*.sqlite3
+*.db
+
+# =========================
+# Models & caches (IMPORTANT for HF)
+# =========================
+models/
+.cache/
+hf_cache/
+transformers_cache/
+
+# =========================
+# Alembic
+# =========================
+alembic/versions/*.pyc
+
+# =========================
+# Logs
+# =========================
+logs/
+*.log
+
+# =========================
+# Test / Temp files
+# =========================
+.tmp/
+.temp/
+*.bak

Dockerfile

@@ -0,0 +1,37 @@
+# Optimized for Hugging Face Spaces
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies (minimal)
+RUN apt-get update && apt-get install -y \
+    curl \
+    postgresql-client \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python packages with cache
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . /app
+
+# Create non-root user
+RUN useradd -m -u 1000 user && \
+    mkdir -p /app/models && \
+    chown -R user:user /app
+
+USER user
+
+# Hugging Face Spaces needs port 7860
+ENV PORT=7860
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=180s \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start server
+CMD uvicorn main:app --host 0.0.0.0 --port 7860 --workers 1

README copy.md

@@ -0,0 +1,38 @@
+# Afiya Care Backend - N-ATLaS Powered Medical Assistant
+
+AI-powered medical assistance with N-ATLaS multilingual support for Awarri Hackathon.
+
+## Features
+- 🇳🇬 N-ATLaS integration (Yoruba, Hausa, Igbo, Pidgin, English)
+- 🔍 Vector-based medical knowledge search
+- ⚠️ Red flag detection for emergencies
+- 🔒 JWT authentication
+- 📱 Offline sync support
+- 🐳 Docker deployment ready
+
+## Quick Start
+```bash
+# Setup
+chmod +x setup.sh
+./setup.sh
+
+# Start
+docker-compose up -d
+
+# API Docs
+open http://localhost:8000/docs
+```
+
+## Test
+```bash
+curl -X POST "http://localhost:8000/api/v1/diagnose" \
+  -H "Content-Type: application/json" \
+  -d '{"symptoms": "Mo ni irora ori", "language": "yo"}'
+```
+
+## Model
+- **N-ATLaS**: NCAIR1/N-ATLaS (Llama-3 8B)
+- **Embeddings**: paraphrase-multilingual-MiniLM-L12-v2
+
+## License
+MIT

README.md

@@ -1,10 +1,36 @@
 ---
-title: Afiya Care
-emoji: 🌖
-colorFrom: green
-colorTo: red
+title: Afiya Care Backend
+emoji: 🏥
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
+license: mit
 ---
 
+# Afiya Care - AI Health Assistant
+
+Powered by N-ATLaS (NCAIR1/N-ATLaS)
+
+## API Endpoints
+
+- `GET /` - Welcome message
+- `GET /health` - Health check
+- `POST /api/v1/diagnose` - Symptom diagnosis
+- `GET /api/v1/languages` - Supported languages
+- `GET /docs` - Interactive API documentation
+
+## Supported Languages
+- English
+- Yoruba
+- Hausa
+- Igbo
+- Nigerian Pidgin
+
+## Usage
+```bash
+curl -X POST "https://YOUR_USERNAME-afiya-care-backend.hf.space/api/v1/diagnose" \
+  -H "Content-Type: application/json" \
+  -d '{"symptoms": "I have a headache", "language": "en"}'
+```
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

alembic.ini

@@ -0,0 +1,56 @@
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
+
+
+; ```
+
+; ### Initialize Alembic
+
+; ```bash
+; # Initialize alembic
+; alembic init alembic
+
+; # Create initial migration
+; alembic revision --autogenerate -m "Initial tables"
+
+; # Apply migration
+; alembic upgrade head
+; ```

core/config.py

@@ -0,0 +1,67 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    # Application
+    APP_NAME: str = "Afiya Care"
+    ENV: str = "development"
+    DEBUG: bool = True
+    API_VERSION: str = "v1"
+    
+    # Server
+    HOST: str = "0.0.0.0"
+    PORT: int = 7860
+    
+    # Database
+    DATABASE_URL: str
+    DB_POOL_SIZE: int = 5
+    DB_MAX_OVERFLOW: int = 10
+    
+    # Vector Database
+    QDRANT_HOST: str
+    QDRANT_PORT: int = 6333
+    QDRANT_API_KEY: str
+    QDRANT_HTTPS: bool = True
+    QDRANT_COLLECTION: str = "medical_knowledge"
+    
+    # Authentication
+    SECRET_KEY: str
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    
+    # N-ATLaS Configuration
+    NATLAS_MODEL: str = "NCAIR1/N-ATLaS"
+    NATLAS_MAX_LENGTH: int = 2048
+    NATLAS_TEMPERATURE: float = 0.7
+    NATLAS_TOP_P: float = 0.9
+    HF_TOKEN: str
+    
+    # Embedding Model
+    EMBEDDING_MODEL: str = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+    MODEL_CACHE_DIR: str = "./models"
+    
+    # Redis
+    REDIS_URL: str
+    
+    # Language Settings
+    DEFAULT_LANGUAGE: str = "en"
+    SUPPORTED_LANGUAGES: str = "en,yo,ha,ig,pcm"
+    ENABLE_AUTO_LANGUAGE_DETECTION: bool = True
+    
+    # Safety & Compliance
+    ENABLE_RED_FLAG_DETECTION: bool = True
+    REQUIRE_DISCLAIMER: bool = True
+    LOG_ANONYMIZATION: bool = True
+    
+    # Rate Limiting
+    RATE_LIMIT_PER_MINUTE: int = 60
+    
+    # Monitoring
+    ENABLE_METRICS: bool = True
+    PROMETHEUS_PORT: int = 9090
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()

core/database.py

@@ -0,0 +1,22 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from .config import  settings
+
+engine = create_engine(
+    settings.DATABASE_URL,
+    pool_size=settings.DB_POOL_SIZE,
+    max_overflow=settings.DB_MAX_OVERFLOW,
+    echo=settings.DEBUG
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_db():
+    """Database session dependency"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

core/security.py

@@ -0,0 +1,56 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against a hash"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password: str) -> str:
+    """Generate password hash"""
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Create JWT access token"""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(
+            minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
+        )
+    
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(
+        to_encode, 
+        settings.SECRET_KEY, 
+        algorithm=settings.ALGORITHM
+    )
+    return encoded_jwt
+
+def verify_token(token: str = Depends(oauth2_scheme)):
+    """Verify JWT token"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(
+            token, 
+            settings.SECRET_KEY, 
+            algorithms=[settings.ALGORITHM]
+        )
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+        return user_id
+    except JWTError:
+        raise credentials_exception

db/models.py

@@ -0,0 +1,57 @@
+from sqlalchemy import Column, Integer, String, Text, DateTime, Boolean, JSON, Float
+from datetime import datetime
+from core.database import Base
+
+class User(Base):
+    """User model for authentication"""
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    is_active = Column(Boolean, default=True)
+    is_admin = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class MedicalCondition(Base):
+    """Medical condition knowledge base"""
+    __tablename__ = "medical_conditions"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, nullable=False, index=True)
+    symptoms = Column(JSON)
+    description = Column(Text)
+    treatments = Column(JSON)
+    red_flags = Column(JSON)
+    tags = Column(JSON)
+    severity_level = Column(String)
+    version = Column(String, default="1.0.0")
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class DiagnosisLog(Base):
+    """Log of diagnosis requests"""
+    __tablename__ = "diagnosis_logs"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, nullable=True)
+    session_id = Column(String, index=True)
+    symptoms_text = Column(Text)
+    detected_language = Column(String)
+    matched_conditions = Column(JSON)
+    red_flags_detected = Column(JSON)
+    response_time_ms = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+class OfflineSync(Base):
+    """Offline synchronization tracking"""
+    __tablename__ = "offline_sync"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, nullable=True)
+    device_id = Column(String, index=True)
+    pending_queries = Column(JSON)
+    client_kb_version = Column(String)
+    synced_at = Column(DateTime, default=datetime.utcnow)
+    sync_status = Column(String, default="pending")

db/schemas.py

@@ -0,0 +1,88 @@
+from pydantic import BaseModel, EmailStr, Field
+from typing import List, Optional, Dict
+from datetime import datetime
+
+# Authentication Schemas
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str = Field(..., min_length=8)
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+# Diagnosis Schemas
+class DiagnosisRequest(BaseModel):
+    symptoms: str = Field(..., min_length=10, max_length=1000)
+    age: Optional[int] = Field(None, ge=0, le=150)
+    gender: Optional[str] = Field(None, pattern="^(male|female|other)$")
+    additional_info: Optional[str] = Field(None, max_length=500)
+    language: Optional[str] = Field(
+        None, 
+        description="Language code (en, yo, ha, ig, pcm)"
+    )
+
+class ConditionMatch(BaseModel):
+    title: str
+    description: str
+    symptoms: List[str]
+    treatments: List[str]
+    severity: str
+    confidence: float
+
+class DiagnosisResponse(BaseModel):
+    conditions: List[ConditionMatch]
+    red_flags: List[str]
+    disclaimer: str
+    response_id: str
+    processing_time_ms: int
+    recommendations: List[str]
+    detected_language: Optional[str] = None
+    natlas_analysis: Optional[str] = None
+
+# Embedding Schemas
+class EmbeddingRequest(BaseModel):
+    text: str = Field(..., min_length=1, max_length=1000)
+    language: Optional[str] = None
+
+class EmbeddingResponse(BaseModel):
+    embedding: List[float]
+    dimension: int
+    model_used: str
+
+# Offline Sync Schemas
+class OfflineSyncRequest(BaseModel):
+    device_id: str
+    pending_queries: List[DiagnosisRequest]
+    client_kb_version: str
+    last_sync_timestamp: Optional[datetime] = None
+
+class OfflineSyncResponse(BaseModel):
+    kb_update_required: bool
+    kb_version: str
+    processed_queries: List[DiagnosisResponse]
+    sync_timestamp: datetime
+
+# Admin Schemas
+class MedicalConditionCreate(BaseModel):
+    title: str
+    symptoms: List[str]
+    description: str
+    treatments: List[str]
+    red_flags: List[str]
+    tags: List[str]
+    severity_level: str
+
+class KnowledgeBaseUpload(BaseModel):
+    conditions: List[MedicalConditionCreate]
+
+class KnowledgeBaseResponse(BaseModel):
+    status: str
+    conditions_added: int
+    conditions_updated: int
+    version: str
+    timestamp: datetime

docker-compose.yml

@@ -0,0 +1,91 @@
+version: '3.8'
+
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: afiya_postgres
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-afiya_user}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-afiya_pass}
+      POSTGRES_DB: ${POSTGRES_DB:-afiya_care}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U afiya_user"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - afiya_network
+
+  qdrant:
+    image: qdrant/qdrant:latest
+    container_name: afiya_qdrant
+    ports:
+      - "6333:6333"
+      - "6334:6334"
+    volumes:
+      - qdrant_data:/qdrant/storage
+    environment:
+      - QDRANT__SERVICE__GRPC_PORT=6334
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:6333/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - afiya_network
+
+  redis:
+    image: redis:7-alpine
+    container_name: afiya_redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    command: redis-server --appendonly yes
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - afiya_network
+
+  backend:
+    build: .
+    container_name: afiya_backend
+    ports:
+      - "8000:8000"
+    environment:
+      - DATABASE_URL=postgresql://afiya_user:afiya_pass@postgres:5432/afiya_care
+      - QDRANT_HOST=qdrant
+      - QDRANT_PORT=6333
+      - REDIS_URL=redis://redis:6379/0
+      - SECRET_KEY=${SECRET_KEY:-change-this-in-production}
+      - NATLAS_MODEL=NCAIR1/N-ATLaS
+      - ENV=production
+      - DEBUG=False
+    depends_on:
+      postgres:
+        condition: service_healthy
+      qdrant:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    volumes:
+      - ./models:/app/models
+    networks:
+      - afiya_network
+    restart: unless-stopped
+
+volumes:
+  postgres_data:
+  qdrant_data:
+  redis_data:
+
+networks:
+  afiya_network:
+    driver: bridge

main.py

@@ -0,0 +1,102 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from prometheus_client import make_asgi_app
+
+from core.config import settings
+from core.database import engine, Base
+from routers import diagnose, embedding, offline, admin, auth
+from services.ml_service import MLService
+from services.vector_service import VectorService
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    print("=" * 60)
+    print("🚀 Starting Afiya Care Backend with N-ATLaS")
+    print("=" * 60)
+    
+    # Initialize database tables
+    print("📊 Creating database tables...")
+    Base.metadata.create_all(bind=engine)
+    print("✅ Database tables created")
+    
+    # Initialize ML service (includes N-ATLaS)
+    print("🤖 Initializing ML Services...")
+    app.state.ml_service = MLService()
+    await app.state.ml_service.initialize()
+    print("✅ ML Services initialized")
+    
+    # Initialize vector service
+    print("💾 Initializing Vector Database...")
+    app.state.vector_service = VectorService()
+    await app.state.vector_service.initialize()
+    print("✅ Vector Database initialized")
+    
+    print("=" * 60)
+    print("✅ Afiya Care Backend Ready!")
+    print(f"📚 API Docs: http://localhost:{settings.PORT}/docs")
+    print(f"🌍 N-ATLaS Languages: Yoruba, Hausa, Igbo, Pidgin, English")
+    print("=" * 60)
+    
+    yield
+    
+    # Shutdown
+    print("\n🛑 Shutting down services...")
+    await app.state.vector_service.close()
+    print("✅ Shutdown complete")
+
+# Get port from environment (HF Spaces uses 7860)
+PORT = settings.PORT
+
+app = FastAPI(
+    title=settings.APP_NAME,
+    description="AI-powered medical assistance with N-ATLaS multilingual support",
+    version=settings.API_VERSION,
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure properly in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Prometheus metrics
+metrics_app = make_asgi_app()
+app.mount("/metrics", metrics_app)
+
+# Include routers
+app.include_router(auth.router, prefix=f"/api/{settings.API_VERSION}/auth", tags=["Authentication"])
+app.include_router(diagnose.router, prefix=f"/api/{settings.API_VERSION}", tags=["Diagnosis"])
+app.include_router(embedding.router, prefix=f"/api/{settings.API_VERSION}", tags=["Embeddings"])
+app.include_router(offline.router, prefix=f"/api/{settings.API_VERSION}/offline", tags=["Offline Sync"])
+app.include_router(admin.router, prefix=f"/api/{settings.API_VERSION}/admin", tags=["Admin"])
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Welcome to Afiya Care API",
+        "version": settings.API_VERSION,
+        "model": "N-ATLaS (NCAIR1/N-ATLaS)",
+        "languages": ["English", "Yoruba", "Hausa", "Igbo", "Nigerian Pidgin"],
+        "status": "operational",
+        "docs": f"/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "database": "connected",
+        "ml_service": "ready",
+        "natlas": "ready",
+        "vector_db": "ready"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=PORT)

requirements.txt

@@ -0,0 +1,55 @@
+# Core FastAPI
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-dotenv==1.0.0
+pydantic==2.5.0
+pydantic-settings==2.1.0
+
+# Database
+sqlalchemy==2.0.23
+psycopg2-binary==2.9.9
+alembic==1.12.1
+
+# Authentication
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+python-multipart==0.0.6
+
+# N-ATLaS and ML Dependencies
+
+transformers >= 4.40.0
+tokenizers >= 0.15.0
+torch==2.2.0
+accelerate==0.25.0
+sentencepiece==0.2.0
+protobuf==3.20.3
+
+# Vector Database
+qdrant-client==1.7.0
+
+# Sentence Transformers (for fallback embeddings)
+sentence-transformers==5.2.0
+
+# Additional ML
+numpy==1.24.3
+pandas==2.1.3
+scikit-learn==1.3.2
+
+# Redis & Celery
+redis==5.0.1
+celery==5.3.4
+
+# Language Detection
+langdetect==1.0.9
+fasttext-wheel==0.9.2
+# fasttext==0.9.2
+
+# Monitoring
+prometheus-client==0.19.0
+
+# Testing
+pytest==7.4.3
+pytest-asyncio==0.21.1
+httpx==0.25.2
+locust==2.18.0
+

routers/admin.py

@@ -0,0 +1,77 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+from datetime import datetime
+
+from core.database import get_db
+from core.security import verify_token
+from db.schemas import KnowledgeBaseUpload, KnowledgeBaseResponse
+from db.models import User, MedicalCondition
+
+router = APIRouter()
+
+def verify_admin(user_id: str = Depends(verify_token), db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.id == int(user_id)).first()
+    if not user or not user.is_admin:
+        raise HTTPException(status_code=403, detail="Admin required")
+    return user
+
+@router.post("/upload-kb", response_model=KnowledgeBaseResponse)
+async def upload_kb(kb_data: KnowledgeBaseUpload, req: Request, db: Session = Depends(get_db), admin: User = Depends(verify_admin)):
+    """Upload knowledge base"""
+    try:
+        from app.services.ml_service import MLService
+        from app.services.vector_service import VectorService
+        
+        ml_service: MLService = req.app.state.ml_service
+        vector_service: VectorService = req.app.state.vector_service
+        
+        added, updated = 0, 0
+        version = f"1.0.{int(datetime.utcnow().timestamp())}"
+        
+        texts, condition_objs = [], []
+        
+        for cond in kb_data.conditions:
+            existing = db.query(MedicalCondition).filter(MedicalCondition.title == cond.title).first()
+            
+            if existing:
+                existing.symptoms = cond.symptoms
+                existing.description = cond.description
+                existing.treatments = cond.treatments
+                existing.version = version
+                updated += 1
+                cond_obj = existing
+            else:
+                cond_obj = MedicalCondition(**cond.dict(), version=version)
+                db.add(cond_obj)
+                added += 1
+            
+            texts.append(f"{cond.title}. {', '.join(cond.symptoms)}. {cond.description}")
+            condition_objs.append(cond_obj)
+        
+        db.commit()
+        
+        embeddings = await ml_service.generate_embeddings_batch(texts)
+        payloads = [
+            {
+                "condition_id": c.id,
+                "title": c.title,
+                "symptoms": c.symptoms,
+                "description": c.description,
+                "treatments": c.treatments,
+                "severity_level": c.severity_level
+            }
+            for c in condition_objs
+        ]
+        
+        await vector_service.insert(embeddings, payloads)
+        
+        return KnowledgeBaseResponse(
+            status="success",
+            conditions_added=added,
+            conditions_updated=updated,
+            version=version,
+            timestamp=datetime.utcnow()
+        )
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))

routers/auth.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from datetime import timedelta
+
+from core.database import get_db
+from core.security import verify_password, get_password_hash, create_access_token, verify_token
+from core.config import settings
+from db.models import User
+from db.schemas import UserCreate, UserLogin, Token
+
+router = APIRouter()
+
+@router.post("/register", response_model=Token)
+async def register(user_data: UserCreate, db: Session = Depends(get_db)):
+    """Register new user"""
+    if db.query(User).filter(User.email == user_data.email).first():
+        raise HTTPException(status_code=400, detail="Email already registered")
+    
+    new_user = User(
+        email=user_data.email,
+        hashed_password=get_password_hash(user_data.password)
+    )
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    
+    token = create_access_token(
+        data={"sub": str(new_user.id)},
+        expires_delta=timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+    return {"access_token": token, "token_type": "bearer"}
+
+@router.post("/login", response_model=Token)
+async def login(user_data: UserLogin, db: Session = Depends(get_db)):
+    """Login"""
+    user = db.query(User).filter(User.email == user_data.email).first()
+    if not user or not verify_password(user_data.password, user.hashed_password):
+        raise HTTPException(status_code=401, detail="Incorrect credentials")
+    
+    token = create_access_token(data={"sub": str(user.id)})
+    return {"access_token": token, "token_type": "bearer"}

routers/diagnose.py

@@ -0,0 +1,90 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+import time
+import uuid
+from typing import List
+
+from core.database import get_db
+from db.schemas import DiagnosisRequest, DiagnosisResponse, ConditionMatch
+from services.ml_service import MLService
+from services.vector_service import VectorService
+from services.safety_service import SafetyService
+from db.models import DiagnosisLog
+
+router = APIRouter()
+
+@router.post("/diagnose", response_model=DiagnosisResponse)
+async def diagnose_symptoms(request: DiagnosisRequest, req: Request, db: Session = Depends(get_db)):
+    """🇳🇬 N-ATLaS powered diagnosis - Supports EN, YO, HA, IG, PCM"""
+    start_time = time.time()
+    session_id = str(uuid.uuid4())
+    
+    try:
+        ml_service: MLService = req.app.state.ml_service
+        vector_service: VectorService = req.app.state.vector_service
+        safety_service = SafetyService()
+        
+        # Detect language
+        detected_lang = request.language or ml_service.detect_language(request.symptoms)
+        print(f"🌍 Language: {detected_lang}")
+        
+        # N-ATLaS analysis
+        natlas_analysis = await ml_service.analyze_with_natlas(request.symptoms, detected_lang)
+        
+        # Generate embedding
+        embedding = await ml_service.generate_embedding(request.symptoms)
+        
+        # Search knowledge base
+        search_results = await vector_service.search(embedding, top_k=5)
+        
+        # Check red flags
+        red_flags = safety_service.detect_red_flags(request.symptoms, detected_lang)
+        
+        # Format conditions
+        conditions: List[ConditionMatch] = []
+        for result in search_results:
+            p = result["payload"]
+            conditions.append(ConditionMatch(
+                title=p.get("title", "Unknown"),
+                description=p.get("description", ""),
+                symptoms=p.get("symptoms", []),
+                treatments=p.get("treatments", []),
+                severity=p.get("severity_level", "moderate"),
+                confidence=round(result["score"], 3)
+            ))
+        
+        recommendations = safety_service.get_recommendations(red_flags)
+        disclaimer = safety_service.get_disclaimer(detected_lang)
+        processing_time = int((time.time() - start_time) * 1000)
+        
+        # Log
+        log = DiagnosisLog(
+            session_id=session_id,
+            symptoms_text=request.symptoms[:100],
+            detected_language=detected_lang,
+            matched_conditions=[c.title for c in conditions],
+            red_flags_detected=[f["category"] for f in red_flags],
+            response_time_ms=processing_time
+        )
+        db.add(log)
+        db.commit()
+        
+        return DiagnosisResponse(
+            conditions=conditions,
+            red_flags=[f["message"] for f in red_flags],
+            disclaimer=disclaimer,
+            response_id=session_id,
+            processing_time_ms=processing_time,
+            recommendations=recommendations,
+            detected_language=detected_lang,
+            natlas_analysis=natlas_analysis[:200]
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/languages")
+async def get_supported_languages(req: Request):
+    """Get supported languages"""
+    ml_service: MLService = req.app.state.ml_service
+    return ml_service.get_model_info()["natlas"]["supported_languages"]

routers/embedding.py

@@ -0,0 +1,21 @@
+from fastapi import APIRouter, Request, HTTPException
+from db.schemas import EmbeddingRequest, EmbeddingResponse
+
+router = APIRouter()
+
+@router.post("/embedding", response_model=EmbeddingResponse)
+async def generate_embedding(request: EmbeddingRequest, req: Request):
+    """Generate embedding"""
+    try:
+        from services.ml_service import MLService
+        ml_service: MLService = req.app.state.ml_service
+        
+        embedding = await ml_service.generate_embedding(request.text, request.language)
+        
+        return EmbeddingResponse(
+            embedding=embedding,
+            dimension=len(embedding),
+            model_used=ml_service.get_model_info()["embedding_model"]
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

routers/offline.py

@@ -0,0 +1,39 @@
+from fastapi import APIRouter, Depends, Request
+from sqlalchemy.orm import Session
+from datetime import datetime
+
+from core.database import get_db
+from db.schemas import OfflineSyncRequest, OfflineSyncResponse
+from db.models import OfflineSync
+
+router = APIRouter()
+KB_VERSION = "1.0.0"
+
+@router.post("/sync", response_model=OfflineSyncResponse)
+async def sync_offline_data(request: OfflineSyncRequest, req: Request, db: Session = Depends(get_db)):
+    """Sync offline data"""
+    from routers.diagnose import diagnose_symptoms
+    
+    processed = []
+    for query in request.pending_queries:
+        try:
+            result = await diagnose_symptoms(query, req, db)
+            processed.append(result)
+        except:
+            continue
+    
+    sync_log = OfflineSync(
+        device_id=request.device_id,
+        pending_queries=[q.dict() for q in request.pending_queries],
+        client_kb_version=request.client_kb_version,
+        sync_status="completed"
+    )
+    db.add(sync_log)
+    db.commit()
+    
+    return OfflineSyncResponse(
+        kb_update_required=request.client_kb_version != KB_VERSION,
+        kb_version=KB_VERSION,
+        processed_queries=processed,
+        sync_timestamp=datetime.utcnow()
+    )

services/ml_service.py

@@ -0,0 +1,71 @@
+from sentence_transformers import SentenceTransformer
+from typing import List, Optional
+import torch
+from core.config import settings
+from services.natlas_service import NATLaSService
+
+class MLService:
+    """ML Service with N-ATLaS and embeddings"""
+    
+    def __init__(self):
+        self.embedding_model = None
+        self.natlas_service = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+    async def initialize(self):
+        """Initialize all ML services"""
+        print(f"🤖 Initializing ML Services on {self.device}")
+        
+        # Load embedding model
+        print(f"📊 Loading: {settings.EMBEDDING_MODEL}")
+        self.embedding_model = SentenceTransformer(
+            settings.EMBEDDING_MODEL,
+            device=self.device
+        )
+        print("✅ Embedding model loaded")
+        
+        # Initialize N-ATLaS
+        self.natlas_service = NATLaSService()
+        await self.natlas_service.initialize()
+    
+    async def generate_embedding(self, text: str, language: Optional[str] = None) -> List[float]:
+        """Generate embedding"""
+        if self.embedding_model is None:
+            raise RuntimeError("Embedding model not initialized")
+        
+        embedding = self.embedding_model.encode(
+            text.strip(),
+            convert_to_numpy=True,
+            normalize_embeddings=True
+        )
+        return embedding.tolist()
+    
+    async def generate_embeddings_batch(self, texts: List[str]) -> List[List[float]]:
+        """Generate embeddings in batch"""
+        if self.embedding_model is None:
+            raise RuntimeError("Embedding model not initialized")
+        
+        embeddings = self.embedding_model.encode(
+            [t.strip() for t in texts],
+            convert_to_numpy=True,
+            batch_size=32,
+            normalize_embeddings=True
+        )
+        return embeddings.tolist()
+    
+    async def analyze_with_natlas(self, symptoms: str, language: str = "en") -> str:
+        """Use N-ATLaS for analysis"""
+        return await self.natlas_service.analyze_symptoms(symptoms, language)
+    
+    def detect_language(self, text: str) -> str:
+        """Detect language"""
+        return self.natlas_service.detect_language(text)
+    
+    def get_model_info(self) -> dict:
+        """Get model information"""
+        return {
+            "embedding_model": settings.EMBEDDING_MODEL,
+            "device": self.device,
+            "dimension": self.embedding_model.get_sentence_embedding_dimension(),
+            "natlas": self.natlas_service.get_model_info()
+        }

services/natlas_service.py

@@ -0,0 +1,226 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+from typing import List, Optional, Dict
+from core.config import settings
+
+
+class NATLaSService:
+    """
+    N-ATLaS Language Model Service
+    Nigerian Atlas for Languages & AI at Scale
+    """
+    
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.supported_languages = {
+            'en': 'English (Nigerian accent)',
+            'yo': 'Yoruba',
+            'ha': 'Hausa',
+            'ig': 'Igbo',
+            'pcm': 'Nigerian Pidgin'
+        }
+        
+    async def initialize(self):
+        """Load N-ATLaS model and tokenizer"""
+        print(f"🇳🇬 Loading N-ATLaS model: {settings.NATLAS_MODEL}")
+        print(f"🔧 Using device: {self.device}")
+        
+        try:
+            # Load tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                settings.NATLAS_MODEL,
+                trust_remote_code=True,
+                use_fast=False, 
+                token=settings.HF_TOKEN,
+            )
+            
+            # Load model
+            self.model = AutoModelForCausalLM.from_pretrained(
+                settings.NATLAS_MODEL,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                trust_remote_code=True
+            )
+            
+            if self.device == "cpu":
+                self.model = self.model.to(self.device)
+            
+            print("✅ N-ATLaS model loaded successfully")
+            print(f"📊 Model size: ~8B parameters (Llama-3 based)")
+            print(f"🌍 Languages: {', '.join(self.supported_languages.values())}")
+            
+        except Exception as e:
+            print(f"❌ Error loading N-ATLaS: {e}")
+            raise RuntimeError(f"Failed to load N-ATLaS model: {e}")
+    
+    async def generate_response(
+        self,
+        prompt: str,
+        language: Optional[str] = "en",
+        max_length: int = None,
+        temperature: float = None,
+        top_p: float = None
+    ) -> str:
+        """
+        Generate response using N-ATLaS
+        
+        Args:
+            prompt: Input prompt/question
+            language: Language code (en, yo, ha, ig, pcm)
+            max_length: Maximum response length
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+        """
+        if self.model is None or self.tokenizer is None:
+            raise RuntimeError("N-ATLaS service not initialized")
+        
+        # Set defaults
+        max_length = max_length or settings.NATLAS_MAX_LENGTH
+        temperature = temperature or settings.NATLAS_TEMPERATURE
+        top_p = top_p or settings.NATLAS_TOP_P
+        
+        # Format prompt for N-ATLaS
+        formatted_prompt = self._format_prompt(prompt, language)
+        
+        # Tokenize
+        inputs = self.tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=max_length
+        ).to(self.device)
+        
+        # Generate
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_length=max_length,
+                temperature=temperature,
+                top_p=top_p,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+        
+        # Decode
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Remove the prompt from response
+        response = response.replace(formatted_prompt, "").strip()
+        
+        return response
+    
+    def _format_prompt(self, prompt: str, language: str) -> str:
+        """
+        Format prompt for N-ATLaS based on language
+        """
+        lang_prefixes = {
+            'en': '',  # Default
+            'yo': '[Yoruba] ',
+            'ha': '[Hausa] ',
+            'ig': '[Igbo] ',
+            'pcm': '[Pidgin] '
+        }
+        
+        prefix = lang_prefixes.get(language, '')
+        return f"{prefix}{prompt}"
+    
+    async def analyze_symptoms_natlas(
+        self,
+        symptoms: str,
+        language: str = "en"
+    ) -> Dict:
+        """
+        Use N-ATLaS to analyze symptoms in local languages
+        
+        Args:
+            symptoms: Patient symptom description
+            language: Language of the symptoms
+        """
+        # Create medical analysis prompt
+        prompt = f"""As a medical assistant, analyze these symptoms and provide:
+1. Possible conditions
+2. Severity level
+3. Recommendations
+
+Symptoms: {symptoms}
+
+Provide a clear, helpful response."""
+        
+        # Generate response
+        response = await self.generate_response(
+            prompt=prompt,
+            language=language,
+            max_length=1024,
+            temperature=0.7
+        )
+        
+        return {
+            "analysis": response,
+            "language": language,
+            "model": "N-ATLaS"
+        }
+    
+    async def translate_medical_info(
+        self,
+        text: str,
+        target_language: str
+    ) -> str:
+        """
+        Translate medical information to local language
+        
+        Args:
+            text: Text to translate
+            target_language: Target language code
+        """
+        prompt = f"Translate the following medical information to {self.supported_languages.get(target_language, 'English')}:\n\n{text}"
+        
+        translation = await self.generate_response(
+            prompt=prompt,
+            language=target_language,
+            max_length=512
+        )
+        
+        return translation
+    
+    def get_model_info(self) -> Dict:
+        """Get N-ATLaS model information"""
+        return {
+            "model_name": settings.NATLAS_MODEL,
+            "architecture": "Llama-3 8B (Fine-tuned)",
+            "device": self.device,
+            "supported_languages": self.supported_languages,
+            "developer": "Awarri Technologies + FMCIDE Nigeria",
+            "training_tokens": "391M+ multilingual tokens",
+            "release": "September 2025"
+        }
+    
+    def detect_language(self, text: str) -> str:
+        """
+        Detect language from text (basic implementation)
+        """
+        text_lower = text.lower()
+        
+        # Yoruba markers
+        yoruba_markers = ['ẹ', 'ọ', 'ṣ', 'bawo', 'e se', 'omo']
+        if any(marker in text_lower for marker in yoruba_markers):
+            return 'yo'
+        
+        # Hausa markers
+        hausa_markers = ['sannu', 'yaya', 'ina', 'ƙ', 'ɗ']
+        if any(marker in text_lower for marker in hausa_markers):
+            return 'ha'
+        
+        # Igbo markers
+        igbo_markers = ['kedu', 'ndewo', 'ị', 'ụ']
+        if any(marker in text_lower for marker in igbo_markers):
+            return 'ig'
+        
+        # Pidgin markers
+        pidgin_markers = ['wetin', 'dey', 'no', 'go', 'fit']
+        pidgin_count = sum(1 for marker in pidgin_markers if marker in text_lower.split())
+        if pidgin_count >= 2:
+            return 'pcm'
+        
+        return 'en'  # Default to English

services/safety_service.py

@@ -0,0 +1,141 @@
+from typing import List, Dict
+import re
+
+class SafetyService:
+    """Medical safety and red flag detection service"""
+    
+    # Critical red flags that require immediate medical attention
+    RED_FLAGS = {
+        "chest_pain": {
+            "patterns": [
+                r"chest pain",
+                r"heart pain",
+                r"tightness in chest",
+                r"crushing sensation",
+                r"pressure in chest"
+            ],
+            "severity": "EMERGENCY",
+            "message": "Chest pain may indicate a heart attack. Call emergency services immediately."
+        },
+        "breathing": {
+            "patterns": [
+                r"can't breathe",
+                r"difficulty breathing",
+                r"shortness of breath",
+                r"gasping for air",
+                r"unable to breathe"
+            ],
+            "severity": "EMERGENCY",
+            "message": "Severe breathing difficulty requires immediate medical attention."
+        },
+        "consciousness": {
+            "patterns": [
+                r"unconscious",
+                r"passed out",
+                r"losing consciousness",
+                r"fainting repeatedly",
+                r"blacking out"
+            ],
+            "severity": "EMERGENCY",
+            "message": "Loss of consciousness is a medical emergency. Call 911/emergency services."
+        },
+        "severe_bleeding": {
+            "patterns": [
+                r"heavy bleeding",
+                r"won't stop bleeding",
+                r"bleeding profusely",
+                r"blood won't clot"
+            ],
+            "severity": "EMERGENCY",
+            "message": "Uncontrolled bleeding requires immediate medical attention."
+        },
+        "stroke": {
+            "patterns": [
+                r"face drooping",
+                r"arm weakness",
+                r"speech difficulty",
+                r"sudden confusion",
+                r"vision loss sudden"
+            ],
+            "severity": "EMERGENCY",
+            "message": "These symptoms may indicate a stroke. Call emergency services immediately. Remember FAST: Face drooping, Arm weakness, Speech difficulty, Time to call 911."
+        },
+        "mental_health_crisis": {
+            "patterns": [
+                r"want to die",
+                r"kill myself",
+                r"end my life",
+                r"suicide",
+                r"not worth living"
+            ],
+            "severity": "CRISIS",
+            "message": "Please contact a crisis helpline immediately. National Suicide Prevention Lifeline: 988. You're not alone, and help is available."
+        },
+        "severe_abdominal_pain": {
+            "patterns": [
+                r"severe abdominal pain",
+                r"intense stomach pain",
+                r"sharp belly pain",
+                r"vomiting blood"
+            ],
+            "severity": "URGENT",
+            "message": "Severe abdominal pain may indicate a serious condition. Seek medical attention promptly."
+        },
+        "head_injury": {
+            "patterns": [
+                r"head injury",
+                r"hit my head hard",
+                r"concussion",
+                r"severe headache after trauma"
+            ],
+            "severity": "URGENT",
+            "message": "Head injuries should be evaluated by a medical professional."
+        }
+    }
+    
+    def detect_red_flags(self, symptoms_text: str) -> List[Dict]:
+        """Detect emergency red flags in symptom text"""
+        detected_flags = []
+        symptoms_lower = symptoms_text.lower()
+        
+        for flag_category, flag_data in self.RED_FLAGS.items():
+            for pattern in flag_data["patterns"]:
+                if re.search(pattern, symptoms_lower):
+                    detected_flags.append({
+                        "category": flag_category,
+                        "severity": flag_data["severity"],
+                        "message": f"⚠️ {flag_data['severity']}: {flag_data['message']}"
+                    })
+                    break  # Only add once per category
+        
+        return detected_flags
+    
+    def get_disclaimer(self) -> str:
+        """Get medical disclaimer"""
+        return (
+            "⚕️ IMPORTANT MEDICAL DISCLAIMER: This AI-powered tool is for "
+            "informational and educational purposes only. It does NOT provide "
+            "medical advice, diagnosis, or treatment. Always consult with a "
+            "qualified healthcare professional for medical concerns. In case of "
+            "emergency, call your local emergency services immediately."
+        )
+    
+    def get_recommendations(self, red_flags: List[Dict]) -> List[str]:
+        """Get safety recommendations based on detected red flags"""
+        recommendations = []
+        
+        if any(flag["severity"] == "EMERGENCY" for flag in red_flags):
+            recommendations.append("🚨 CALL EMERGENCY SERVICES IMMEDIATELY")
+            recommendations.append("Do not wait - this could be life-threatening")
+        elif any(flag["severity"] == "CRISIS" for flag in red_flags):
+            recommendations.append("📞 Contact a crisis helpline now - help is available 24/7")
+            recommendations.append("National Suicide Prevention Lifeline: 988")
+        elif any(flag["severity"] == "URGENT" for flag in red_flags):
+            recommendations.append("⏰ Seek medical attention within 24 hours")
+            recommendations.append("Consider visiting urgent care or emergency department")
+        else:
+            recommendations.append("✅ Monitor your symptoms")
+            recommendations.append("Consult a healthcare provider if symptoms worsen")
+            recommendations.append("Keep a symptom diary to share with your doctor")
+        
+        return recommendations

services/vector_service.py

@@ -0,0 +1,123 @@
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct, Filter, FieldCondition, MatchValue
+from typing import List, Dict, Optional
+from core.config import settings
+import uuid
+
+class VectorService:
+    """Vector database service using Qdrant"""
+    
+    def __init__(self):
+        self.client = None
+        
+    async def initialize(self):
+        """Initialize Qdrant client and create collection"""
+        print(f"🔗 Connecting to Qdrant at {settings.QDRANT_HOST}:{settings.QDRANT_PORT}")
+        
+        self.client = QdrantClient(
+            host=settings.QDRANT_HOST,
+            port=settings.QDRANT_PORT,
+            timeout=30
+        )
+        
+        # Create collection if it doesn't exist
+        try:
+            collections = self.client.get_collections().collections
+            collection_names = [c.name for c in collections]
+            
+            if settings.QDRANT_COLLECTION not in collection_names:
+                self.client.create_collection(
+                    collection_name=settings.QDRANT_COLLECTION,
+                    vectors_config=VectorParams(
+                        size=384,  # all-MiniLM-L6-v2 dimension
+                        distance=Distance.COSINE
+                    )
+                )
+                print(f"✅ Created Qdrant collection: {settings.QDRANT_COLLECTION}")
+            else:
+                print(f"✅ Qdrant collection exists: {settings.QDRANT_COLLECTION}")
+                
+        except Exception as e:
+            print(f"❌ Error initializing Qdrant: {e}")
+            raise
+    
+    async def insert(
+        self, 
+        embeddings: List[List[float]], 
+        payloads: List[Dict]
+    ) -> int:
+        """Insert embeddings with metadata"""
+        points = [
+            PointStruct(
+                id=str(uuid.uuid4()),
+                vector=embedding,
+                payload=payload
+            )
+            for embedding, payload in zip(embeddings, payloads)
+        ]
+        
+        result = self.client.upsert(
+            collection_name=settings.QDRANT_COLLECTION,
+            points=points
+        )
+        
+        return len(points)
+    
+    async def search(
+        self, 
+        query_embedding: List[float], 
+        top_k: int = 5,
+        filters: Optional[Dict] = None
+    ) -> List[Dict]:
+        """Search for similar vectors"""
+        
+        # Build filter if provided
+        search_filter = None
+        if filters:
+            conditions = []
+            for key, value in filters.items():
+                conditions.append(
+                    FieldCondition(
+                        key=key,
+                        match=MatchValue(value=value)
+                    )
+                )
+            search_filter = Filter(must=conditions)
+        
+        results = self.client.search(
+            collection_name=settings.QDRANT_COLLECTION,
+            query_vector=query_embedding,
+            limit=top_k,
+            query_filter=search_filter
+        )
+        
+        return [
+            {
+                "id": result.id,
+                "score": result.score,
+                "payload": result.payload
+            }
+            for result in results
+        ]
+    
+    async def delete_by_id(self, point_id: str):
+        """Delete a point by ID"""
+        self.client.delete(
+            collection_name=settings.QDRANT_COLLECTION,
+            points_selector=[point_id]
+        )
+    
+    async def get_collection_info(self) -> Dict:
+        """Get collection information"""
+        info = self.client.get_collection(settings.QDRANT_COLLECTION)
+        return {
+            "vectors_count": info.vectors_count,
+            "points_count": info.points_count,
+            "status": info.status
+        }
+    
+    async def close(self):
+        """Close the client connection"""
+        if self.client:
+            self.client.close()
+            print("✅ Qdrant connection closed")

setup.bat

@@ -0,0 +1,63 @@
+# #!/bin/bash
+# echo "🚀 Afiya Care Setup"
+# echo "==================="
+
+# # Create directories
+# mkdir -p models alembic/versions
+
+# # Copy .env
+# if [ ! -f .env ]; then
+#     cp .env.example .env
+#     echo "✅ Created .env file"
+# fi
+
+# # Start Docker services
+# echo "🐳 Starting services..."
+# docker-compose up -d postgres qdrant redis
+# sleep 10
+
+# # Install dependencies
+# echo "📦 Installing dependencies..."
+# pip install -r requirements.txt
+
+# # Run migrations
+# echo "🗄️ Running migrations..."
+# alembic upgrade head
+
+# echo "✅ Setup complete!"
+# echo "Start backend: uvicorn app.main:app --reload"
+
+
+# CMD
+
+@echo off
+echo 🚀 Afiya Care Setup
+echo ===================
+
+REM --- Create directories ---
+if not exist models mkdir models
+if not exist alembic mkdir alembic
+if not exist alembic\versions mkdir alembic\versions
+
+REM --- Copy .env if missing ---
+if not exist .env (
+    copy .env.example .env
+    echo ✅ Created .env file
+)
+
+REM --- Start Docker services ---
+echo 🐳 Starting services...
+docker-compose up -d postgres qdrant redis
+timeout /t 10 >nul
+
+REM --- Install dependencies ---
+echo 📦 Installing dependencies...
+pip install -r requirements.txt
+
+REM --- Run migrations ---
+echo 🗄️ Running migrations...
+alembic upgrade head
+
+echo ✅ Setup complete!
+echo Start backend: uvicorn app.main:app --reload
+pause