Update app.py

app.py

@@ -1,65 +1,47 @@
 from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from transformers import AutoTokenizer
 from onnxruntime import InferenceSession
+from transformers import AutoTokenizer
 import numpy as np
 import os
-from typing import Dict
 
-app = FastAPI(title="ONNX Model API with Tokenizer")
+app = FastAPI()
 
-# CORS configuration
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
+# Initialize tokenizer (doesn't require PyTorch/TensorFlow)
+tokenizer = AutoTokenizer.from_pretrained(
+    "Xenova/multi-qa-mpnet-base-dot-v1",
+    use_fast=True,  # Uses Rust implementation
+    legacy=False
 )
 
-# Initialize components
-tokenizer = AutoTokenizer.from_pretrained("Xenova/multi-qa-mpnet-base-dot-v1")
+# Load ONNX model
 session = InferenceSession("model.onnx")
 
-def convert_outputs(outputs):
-    """Ensure all numpy values are converted to Python native types"""
-    if isinstance(outputs, (np.generic, np.ndarray)):
-        return outputs.item() if outputs.ndim == 0 else outputs.tolist()
-    return outputs
-
-@app.post("/api/process")
-async def process_text(request: Dict[str, str]):
+@app.post("/api/predict")
+async def predict(text: str):
     try:
-        text = request.get("text", "")
-        
-        # Tokenize the input text
+        # Tokenize without framework dependencies
         inputs = tokenizer(
             text,
-            return_tensors="np",
+            return_tensors="np",  # Get NumPy arrays directly
             padding=True,
             truncation=True,
             max_length=32  # Match your model's expected input size
         )
         
-        # Convert to ONNX-compatible format
+        # Prepare ONNX inputs
         onnx_inputs = {
             "input_ids": inputs["input_ids"].astype(np.int64),
             "attention_mask": inputs["attention_mask"].astype(np.int64)
         }
         
-        # Run model inference
+        # Run inference
         outputs = session.run(None, onnx_inputs)
         
-        # Convert all numpy types to native Python types
-        processed_outputs = [convert_outputs(output) for output in outputs]
-        
+        # Convert to native Python types
         return {
-            "embedding": processed_outputs[0],  # Assuming first output is embeddings
+            "embedding": outputs[0].astype(np.float32).tolist(),
             "tokens": tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
         }
         
     except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy"}
+        raise HTTPException(status_code=400, detail=str(e))