example/backend/server.py

from decouple import config
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pathlib import Path
from pydantic import BaseModel
import uvicorn
import json
import numpy as np
import torch
import faiss
import time
from transformers import AutoTokenizer, AutoModelForCausalLM
import voyageai
from typing import List, Dict, Any, Optional

# File paths from .env file
VOYAGE_API_KEY = config("VOYAGE_API_KEY")
EMBEDDINGS_FINAL = "/home/ianwu/projects/exampleSvelteRepo/example/backend/mmsci/paper_embeddings/embeddings_final.npy" # path to the embeddings file
PAPER_FINAL = "/home/ianwu/projects/exampleSvelteRepo/example/backend/mmsci/paper_embeddings/paper_final.json" # path to the papers file
PAPER_FINAL_PATH_PREFIX = "" # path to prefix of the paper files

# Initialize FastAPI
app = FastAPI(title="BioPACIFIC MIP Research Paper RAG API")

# Configure CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # In production, replace with your Svelte app's domain
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Load existing embeddings and papers
paper_embeddings = np.load(EMBEDDINGS_FINAL)

dimension = paper_embeddings.shape[1]  # Get embedding dimension

# Initialize FAISS index
index = faiss.IndexFlatIP(dimension)  # Use Inner Product similarity
index.add(paper_embeddings)

with open(PAPER_FINAL, "r") as f:
    papers = json.load(f)

# Initialize models and tokenizer
model_name = "Qwen/Qwen3-8B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="cpu",
)

# Initialize VoyageAI client
voyage_client = voyageai.Client(api_key=VOYAGE_API_KEY)

class QueryRequest(BaseModel):
    message: str

class PaperInfo(BaseModel):
    title: str
    abstract: str
    similarity: str
    link: str

class QueryResponse(BaseModel):
    response: str
    papers: List[PaperInfo]

def get_voyage_embedding(text, model="voyage-3-lite"):
    """Get embeddings for text using VoyageAI API with rate limiting and retry logic."""
    max_retries = 3
    retry_delay = 5
    
    for attempt in range(max_retries):
        try:
            response = voyage_client.embed(
                model=model,
                texts=[text]
            )
            return np.array(response.embeddings[0])
            
        except Exception as e:
            if attempt == max_retries - 1:  # Last attempt
                print(f"Failed after {max_retries} attempts: {str(e)}")
                return None
            print(f"Attempt {attempt + 1} failed: {str(e)}. Retrying in {retry_delay} seconds...")
            time.sleep(retry_delay)
            retry_delay *= 2  # Exponential backoff

def find_relevant_papers(query_embedding, top_k=5):
    # Perform similarity search using FAISS
    scores, indices = index.search(query_embedding.reshape(1, -1), top_k)
    
    # Get the papers and their similarity scores
    relevant_papers = [papers[idx] for idx in indices[0]]
    similarities = scores[0]  # Scores are already cosine similarities
    
    return relevant_papers, similarities

def format_papers_context(papers, similarities):
    relevant_papers = []
    context = "Based on the following relevant papers:\n\n"
    for paper, similarity in zip(papers, similarities):
        original_paper = json.load(open(Path(PAPER_FINAL_PATH_PREFIX, paper['path'])))
        relevant_papers.append(original_paper)
        context += f"Title: {original_paper['title']}\n\n"
        context += f"Published Time: {original_paper['published_time']}\n\n"
        context += f"Abstract: {original_paper['abstract']}\n\n"
    context += "Question: "
    # context += "Please use the information from the retrieved papers to answer the question. Do not reference or recommend papers that weren't retrieved.\n\n"
    return context, relevant_papers

# Simple API health checker route.
@app.get("/")
async def hello():
    return {"message": "hello"}

@app.post("/api/query", response_model=QueryResponse)
async def generate_response(request: QueryRequest):
    try:
        # Generate embedding for the query
        query_embedding = get_voyage_embedding(request.message)
        
        if query_embedding is None:
            raise HTTPException(status_code=500, detail="Failed to generate embedding")
        
        # Find relevant papers
        relevant_papers, similarities = find_relevant_papers(query_embedding)

        # Create context from relevant papers
        context, paper_objects = format_papers_context(relevant_papers, similarities)

        # Prepare the prompt with context
        system_prompt = """You are a helpful assistant specializing in materials science. Follow these guidelines:

1. For general questions not requiring scientific papers:
   - Answer directly using your knowledge
   - No need to reference papers

2. For scientific research questions:
   - If the question can be answered using the retrieved papers, answer using the retrieved papers
   - If the question cannot be answered using the retrieved papers, say so
   - Do not reference or recommend papers that weren't retrieved

3. Never generate or recommend papers that weren't retrieved in the context."""

        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": context + request.message}
        ]
        # Use chat template if available, else fallback
        if hasattr(tokenizer, "apply_chat_template"):
            text = tokenizer.apply_chat_template(
                messages,
                tokenize=False,
                add_generation_prompt=True,
                enable_thinking=False
            )
        else:
            # Fallback: simple concatenation
            text = f"{system_prompt}\n\nUser: {context}{request.message}\n\nAssistant:"
        # Generate response using model
        inputs = tokenizer(text, return_tensors="pt").to(model.device)
        with torch.no_grad():
            outputs = model.generate(
                inputs.input_ids,
                max_new_tokens=16,
                num_return_sequences=1,
                temperature=0.7,
                do_sample=True,
                pad_token_id=tokenizer.eos_token_id,
                eos_token_id=tokenizer.eos_token_id,
            )
        response = tokenizer.decode(outputs[0][len(inputs.input_ids[0]):], skip_special_tokens=True)
        # Format paper info for response (top 3)
        paper_info = []
        for i in range(min(3, len(paper_objects))):
            paper_info.append(PaperInfo(
                title=paper_objects[i]['title'],
                abstract=paper_objects[i]['abstract'],
                similarity=f"Similarity Score: {similarities[i]:.3f}",
                link=paper_objects[i]['pdf_link']
            ))

        # Ensure we have exactly 3 papers in the response
        while len(paper_info) < 3:
            paper_info.append(PaperInfo(
                title="",
                abstract="",
                similarity="",
                link=""
            ))
            
        return QueryResponse(
            response=response,
            papers=paper_info
        )
    
    except Exception as e:
        print(f"Error processing request: {str(e)}")
        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")

if __name__ == "__main__":
    uvicorn.run("server:app", host="0.0.0.0", port=8000, reload=True)