Added complete LLM Claims API project

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,100 @@
+# main.py
+import os
+import json
+import uuid
+
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+from dotenv import load_dotenv
+from utils.loader import extract_text_from_pdf
+from utils.evaluator import evaluate
+from utils.parser import parse_query_with_gemini
+
+import google.generativeai as genai
+
+# Load environment variables
+load_dotenv()
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+print("Loaded Gemini API Key:", os.getenv("GEMINI_API_KEY"))
+app = FastAPI()
+
+# Ensure data directory exists
+os.makedirs("data/documents", exist_ok=True)
+
+@app.get("/")
+def root():
+    return {"message": "LLM Claims API is up and running!"}
+
+@app.post("/evaluate")
+async def evaluate_query(query: str = Form(...), file: UploadFile = File(...)):
+    # Save uploaded file
+    file_id = str(uuid.uuid4())
+    file_path = f"data/documents/{file_id}.pdf"
+    with open(file_path, "wb") as f:
+        f.write(await file.read())
+
+    try:
+        # Extract and parse
+        policy_text = extract_text_from_pdf(file_path)
+
+        parsed_query = await parse_query_with_gemini(query) \
+            if callable(getattr(parse_query_with_gemini, "__await__", None)) else parse_query_with_gemini(query)
+        
+        gemini_response = await query_gemini(policy_text, query)
+
+        rule_decision = evaluate(parsed_query, gemini_response.get("matched_clause", ""))
+
+        final_result = {
+            **gemini_response,
+            "parsed_query": parsed_query,
+            "rule_based_decision": rule_decision,
+        }
+
+    except Exception as e:
+        final_result = {
+            "error": str(e)
+        }
+
+    finally:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+    return JSONResponse(content=final_result)
+
+
+async def query_gemini(policy_text: str, query_text: str):
+    model = genai.GenerativeModel("models/gemini-1.5-flash-latest")
+    
+    prompt = f"""
+You are an insurance claim evaluator. Based on the policy document and query, respond in JSON with:
+1. decision: 'approved' or 'rejected'
+2. justification: brief explanation
+3. amount: estimated payout
+4. matched_clause: snippet of the policy that supports the decision
+5. similarity_score: float between 0 and 1
+
+Policy:
+{policy_text}
+
+Query:
+{query_text}
+"""
+
+    try:
+        response = model.generate_content(prompt)
+        content = response.text.strip()
+
+        # Clean markdown-style code formatting
+        if content.startswith("```json") or content.startswith("```"):
+            content = content.replace("```json", "").replace("```", "").strip()
+
+        return json.loads(content)
+
+    except Exception as e:
+        return {
+            "decision": "rejected",
+            "justification": f"Gemini Error: {str(e)}",
+            "amount": "₹0",
+            "matched_clause": "",
+            "similarity_score": 0.0
+        }

models/embedder.py

@@ -0,0 +1,13 @@
+from sentence_transformers import SentenceTransformer
+
+model = SentenceTransformer('all-MiniLM-L6-v2', device='cpu')
+
+def get_embedding(text: str):
+    try:
+        vec = model.encode(text)
+        vec = vec.flatten()
+        assert vec.shape[0] == 384, f"Expected embedding of size 384, got {vec.shape[0]}"
+        return vec
+    except Exception as e:
+        print(f"Embedding Error: {e}")
+        return None

requirements.txt

@@ -0,0 +1,20 @@
+fastapi
+uvicorn
+python-multipart
+pypdf
+gradio
+sentence-transformers
+pinecone-client
+pinecone-text
+transformers
+datasets
+torch
+python-dotenv
+pandas
+scikit-learn
+tqdm
+Pillow
+# Add this:
+google-generativeai
+# Optional: remove this if OpenAI is no longer needed
+# openai

utils/evaluator.py

@@ -0,0 +1,23 @@
+def evaluate(parsed_query: dict, matched_clause: str) -> dict:
+    procedure = parsed_query.get("procedure", "")
+    duration = parsed_query.get("policy_duration", "")
+
+    if not matched_clause or not procedure:
+        return {
+            "decision": "rejected",
+            "justification": "Unable to match clause or detect procedure from query.",
+            "amount": "₹0"
+        }
+
+    if procedure.lower() in matched_clause.lower():
+        return {
+            "decision": "approved",
+            "justification": f"{procedure.capitalize()} is covered under the policy. Clause matched.",
+            "amount": "₹80,000"
+        }
+
+    return {
+        "decision": "rejected",
+        "justification": "Procedure not clearly mentioned in policy document.",
+        "amount": "₹0"
+    }

utils/loader.py

@@ -0,0 +1,13 @@
+import fitz  # PyMuPDF
+
+def extract_text_from_pdf(pdf_path: str) -> str:
+    text = ""
+    try:
+        with fitz.open(pdf_path) as doc:
+            for page in doc:
+                text += page.get_text()
+        return text.replace("\n", " ").replace("  ", " ").strip()
+    except Exception as e:
+        print(f"PDF Extraction Error: {e}")
+        return ""
+

utils/parser.py

@@ -0,0 +1,35 @@
+# parser.py
+import json
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+def parse_query_with_gemini(query: str):
+    model = genai.GenerativeModel("models/gemini-1.5-flash-latest")
+    prompt = f"""
+You are an intelligent insurance assistant.
+Given a natural language query, extract the following fields as JSON. Do not include any explanation or extra text — just valid JSON:
+
+- age (integer)
+- gender (male/female/unknown)
+- procedure (string)
+- location (string)
+- policy_duration_months (integer)
+
+Query:
+"{query}"
+"""
+    try:
+        response = model.generate_content(prompt)
+        response_text = response.text.strip()
+        if response_text.startswith("```"):
+            response_text = response_text.strip("`").replace("json", "").strip()
+        return json.loads(response_text)
+    except Exception as e:
+        return {
+            "error": "Failed to parse Gemini response",
+            "raw_response": response.text if 'response' in locals() else str(e)
+        }