Upload 4 files

config.py

@@ -0,0 +1,13 @@
+import os
+
+# In a production Hugging Face Space, set these as Secrets
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
+MY_PUBMED_EMAIL = os.getenv("MY_PUBMED_EMAIL", "[email protected]")
+
+# Default LLM models
+OPENAI_DEFAULT_MODEL = "gpt-3.5-turbo"
+GEMINI_DEFAULT_MODEL = "models/chat-bison-001"
+
+# Summarization chunk size
+DEFAULT_CHUNK_SIZE = 512

image_pipeline.py

@@ -0,0 +1,16 @@
+from transformers import pipeline
+
+def load_image_model():
+    """
+    Loads HuggingFaceTB/SmolVLM-500M-Instruct or another image-to-text model.
+    """
+    return pipeline("image-to-text", model="HuggingFaceTB/SmolVLM-500M-Instruct")
+
+def analyze_image(image_file, image_model):
+    """
+    Pass an image file to the image model pipeline and return the text/caption.
+    """
+    result = image_model(image_file)
+    if isinstance(result, list) and len(result) > 0:
+        return result[0].get("generated_text", "No caption generated.")
+    return "Unable to process image."

models.py

@@ -0,0 +1,48 @@
+import openai
+import google.generativeai as genai
+from config import OPENAI_API_KEY, GEMINI_API_KEY, OPENAI_DEFAULT_MODEL, GEMINI_DEFAULT_MODEL
+
+def configure_llms():
+    """
+    Call this at startup or inside your main app file to configure 
+    OpenAI and Gemini if keys are available.
+    """
+    if OPENAI_API_KEY:
+        openai.api_key = OPENAI_API_KEY
+    if GEMINI_API_KEY:
+        genai.configure(api_key=GEMINI_API_KEY)
+
+def openai_chat(system_prompt, user_prompt, model=None, temperature=0.3):
+    """
+    Basic ChatCompletion with system + user roles for OpenAI.
+    """
+    if not OPENAI_API_KEY:
+        return "Error: OpenAI API key not provided."
+    chat_model = model or OPENAI_DEFAULT_MODEL
+    try:
+        response = openai.ChatCompletion.create(
+            model=chat_model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=temperature
+        )
+        return response.choices[0].message["content"].strip()
+    except Exception as e:
+        return f"Error calling OpenAI: {str(e)}"
+
+def gemini_chat(system_prompt, user_prompt, model_name=None, temperature=0.3):
+    """
+    Basic call to Google PaLM2 via google.generativeai.
+    """
+    if not GEMINI_API_KEY:
+        return "Error: Gemini API key not provided."
+    final_model_name = model_name or GEMINI_DEFAULT_MODEL
+    try:
+        model = genai.GenerativeModel(model_name=final_model_name)
+        chat_session = model.start_chat(history=[("system", system_prompt)])
+        reply = chat_session.send_message(user_prompt, temperature=temperature)
+        return reply.text
+    except Exception as e:
+        return f"Error calling Gemini: {str(e)}"

pubmed_utils.py

@@ -0,0 +1,96 @@
+import requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import nltk
+nltk.download('punkt')
+from nltk.tokenize import sent_tokenize
+
+from transformers import pipeline
+from config import MY_PUBMED_EMAIL
+
+# Build a summarization pipeline at module load (caching recommended)
+summarizer = pipeline("summarization", model="facebook/bart-large-cnn", tokenizer="facebook/bart-large-cnn")
+
+def search_pubmed(query, max_results=3):
+    """
+    Searches PubMed via ESearch and returns list of PMIDs.
+    """
+    base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
+    params = {
+        "db": "pubmed",
+        "term": query,
+        "retmax": max_results,
+        "retmode": "json",
+        "tool": "ElysiumRAG",
+        "email": MY_PUBMED_EMAIL
+    }
+    resp = requests.get(base_url, params=params)
+    resp.raise_for_status()
+    data = resp.json()
+    return data.get("esearchresult", {}).get("idlist", [])
+
+def fetch_one_abstract(pmid):
+    """
+    Fetches abstract for a given PMID. Returns (pmid, text).
+    """
+    base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi"
+    params = {
+        "db": "pubmed",
+        "retmode": "text",
+        "rettype": "abstract",
+        "id": pmid,
+        "tool": "ElysiumRAG",
+        "email": MY_PUBMED_EMAIL
+    }
+    resp = requests.get(base_url, params=params)
+    resp.raise_for_status()
+    raw_text = resp.text.strip() or "No abstract text found."
+    return (pmid, raw_text)
+
+def fetch_pubmed_abstracts(pmids):
+    """
+    Parallel retrieval of multiple PMIDs.
+    """
+    if not pmids:
+        return {}
+
+    results_map = {}
+    with ThreadPoolExecutor(max_workers=min(len(pmids), 5)) as executor:
+        future_to_pmid = {executor.submit(fetch_one_abstract, pmid): pmid for pmid in pmids}
+        for future in as_completed(future_to_pmid):
+            pmid = future_to_pmid[future]
+            try:
+                pmid_result, text = future.result()
+                results_map[pmid_result] = text
+            except Exception as e:
+                results_map[pmid] = f"Error: {str(e)}"
+    return results_map
+
+def chunk_and_summarize(abstract_text, chunk_size=512):
+    """
+    Chunk large abstracts by sentence, summarize each chunk, then combine.
+    """
+    sentences = sent_tokenize(abstract_text)
+    chunks = []
+
+    current_chunk = []
+    current_length = 0
+    for sent in sentences:
+        tokens_in_sent = len(sent.split())
+        if current_length + tokens_in_sent > chunk_size:
+            chunks.append(" ".join(current_chunk))
+            current_chunk = []
+            current_length = 0
+        current_chunk.append(sent)
+        current_length += tokens_in_sent
+
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+
+    summarized_pieces = []
+    for c in chunks:
+        summary_out = summarizer(
+            c, max_length=100, min_length=30, do_sample=False
+        )
+        summarized_pieces.append(summary_out[0]['summary_text'])
+
+    return " ".join(summarized_pieces).strip()