Add application file

Dockerfile

@@ -0,0 +1,18 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copy app code
+COPY . .
+
+# Expose the port FastAPI uses
+EXPOSE 8000
+
+# Run the FastAPI app and the Gradio demo concurrently using a process manager (or choose one)
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,14 +1 @@
----
-title: Materials Ai App
-emoji: 🏃
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 5.23.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Materials science web application that leverages domain‐spec
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Project overview and instructions 

app/main.py

@@ -0,0 +1,46 @@
+# app/main.py
+import uvicorn
+from fastapi import FastAPI, HTTPException, File, UploadFile
+from pydantic import BaseModel
+from app import models, openai_integration
+
+app = FastAPI(title="Materials AI Extraction API")
+
+# Pydantic models for request/response bodies
+class ExtractionRequest(BaseModel):
+    text: str
+
+class QueryRequest(BaseModel):
+    query: str
+
+class SummarizeRequest(BaseModel):
+    text: str
+
+@app.post("/extract")
+async def extract_data(request: ExtractionRequest):
+    try:
+        # Use our domain-specific model (e.g. MatSciBERT or BatteryBERT) for token classification
+        extracted = models.extract_entities(request.text)
+        return {"entities": extracted}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/query")
+async def query_data(request: QueryRequest):
+    try:
+        # This endpoint performs a Q&A on the provided query using the domain models
+        answer = models.answer_question(request.query)
+        return {"answer": answer}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/summarize")
+async def summarize(request: SummarizeRequest):
+    try:
+        summary = openai_integration.generate_summary(request.text)
+        return {"summary": summary}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/models.py

@@ -0,0 +1,30 @@
+# app/models.py
+from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
+import torch
+
+# Load a domain-specific model (example: MatSciBERT for materials text)
+MATS_BERT_MODEL = "m3rg-iitd/matscibert"  # adjust model name as needed
+tokenizer = AutoTokenizer.from_pretrained(MATS_BERT_MODEL)
+model = AutoModelForTokenClassification.from_pretrained(MATS_BERT_MODEL)
+
+# Create a pipeline for token classification (NER, relation extraction)
+ner_pipeline = pipeline("ner", model=model, tokenizer=tokenizer, aggregation_strategy="simple")
+
+def extract_entities(text: str):
+    """
+    Process text using a domain-specific BERT model to extract entities.
+    """
+    results = ner_pipeline(text)
+    # Format the output as a list of (entity, score, start, end)
+    entities = [{"entity": r["entity_group"], "word": r["word"], "score": r["score"]} for r in results]
+    return entities
+
+def answer_question(query: str):
+    """
+    For demonstration, we use a simple approach.
+    In practice, you may combine a retrieval step with a Q&A model.
+    """
+    # For example purposes, we simulate an answer by echoing the query.
+    # Replace this with your domain-specific Q&A logic.
+    return f"Simulated answer for query: '{query}'"
+# Model loading and inference functions 

app/openai_integration.py

@@ -0,0 +1,18 @@
+# app/openai_integration.py
+import openai
+import os
+
+# Set your OpenAI API key from environment variables
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+def generate_summary(text: str) -> str:
+    """
+    Generate a summary of the given text using GPT-4.
+    """
+    response = openai.ChatCompletion.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": f"Please summarize the following text:\n\n{text}"}],
+        temperature=0.3
+    )
+    summary = response.choices[0].message["content"].strip()
+    return summary

app/utils.py

@@ -0,0 +1 @@
+# Utility functions, e.g., PDF/text parsing 

gradio_app.py

@@ -0,0 +1,37 @@
+# gradio_app.py
+import gradio as gr
+import requests
+import os
+
+# URL of the backend API (if hosted separately, otherwise use local endpoints)
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+def extract_interface(text):
+    response = requests.post(f"{API_URL}/extract", json={"text": text})
+    if response.ok:
+        return response.json()["entities"]
+    else:
+        return {"error": response.text}
+
+def summarize_interface(text):
+    response = requests.post(f"{API_URL}/summarize", json={"text": text})
+    if response.ok:
+        return response.json()["summary"]
+    else:
+        return {"error": response.text}
+
+with gr.Blocks(title="Materials AI Extraction Demo") as demo:
+    gr.Markdown("## Materials Science AI Extraction")
+    with gr.Tabs():
+        with gr.TabItem("Extract Entities"):
+            input_text = gr.Textbox(label="Enter Materials Science Text", lines=5)
+            output_entities = gr.JSON(label="Extracted Entities")
+            extract_btn = gr.Button("Extract")
+            extract_btn.click(fn=extract_interface, inputs=input_text, outputs=output_entities)
+        with gr.TabItem("Summarize Text"):
+            summary_input = gr.Textbox(label="Enter Text to Summarize", lines=5)
+            summary_output = gr.Textbox(label="Summary")
+            summarize_btn = gr.Button("Summarize")
+            summarize_btn.click(fn=summarize_interface, inputs=summary_input, outputs=summary_output)
+
+demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn[standard]
+transformers
+torch
+openai
+gradio
+requests
+pydantic

run_backend.cmd

@@ -0,0 +1,4 @@
+@echo off
+REM Optionally activate your virtual environment here, e.g., call venv\Scripts\activate
+python app/main.py
+pause

run_gradio.cmd

@@ -0,0 +1,4 @@
+@echo off
+REM Optionally activate your virtual environment here, e.g., call venv\Scripts\activate
+python gradio_app.py
+pause