Hugging-Face Deployment

.dockerignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*.pyo
+.cache/
+venv/
+.env
+*.faiss
+*.pkl
+*.json
+testing/
+redis/

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,213 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+cache/
+database/
+# C extensions
+*.so
+.idea/
+
+# Distribution / packaging
+.Python
+build/
+testing/
+develop-eggs/
+dist/
+redis/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+redis/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+V2
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

Dockerfile

@@ -0,0 +1,80 @@
+# ---------- Builder Stage ----------
+FROM python:3.11-bookworm AS builder
+
+WORKDIR /app
+
+# Install system build dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    pkg-config \
+    libhdf5-dev \
+    libopenblas-dev \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Install Python packages
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Set cache locations
+ENV HF_HOME=/app/hf_cache/huggingface
+ENV HF_DATASETS_CACHE=/app/hf_cache/datasets
+
+# Pre-download model
+RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
+
+# ---------- Production Stage ----------
+FROM python:3.11-bookworm AS production
+
+# Create non-root user
+RUN groupadd -r appuser && useradd -r -g appuser appuser
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgomp1 \
+    libopenblas0 \
+    libhdf5-103 \
+    curl \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy Python dependencies and scripts
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+
+# Copy Hugging Face model cache and fix permissions
+COPY --from=builder /app/hf_cache /app/cache
+RUN chown -R appuser:appuser /app/cache
+
+# Copy application code
+COPY . .
+
+# Create necessary directories and fix permissions
+RUN mkdir -p \
+    /app/database/faiss_index \
+    /app/cache/datasets \
+    /home/appuser/.cache/huggingface \
+    /app/vector_store \
+    /app/temp_vector_store && \
+    chown -R appuser:appuser /app /home/appuser
+
+# Switch to non-root user
+USER appuser
+
+# Expose app port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Environment variables
+ENV PYTHONPATH=/app \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    HF_HOME=/app/cache/huggingface \
+    HF_DATASETS_CACHE=/app/cache/datasets
+
+# Launch FastAPI app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,3 +1,4 @@
+
 ---
 title: PDF Summarization
 emoji: 🐢
@@ -9,3 +10,299 @@ short_description: PDF-Summarization
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## 📦 Project Info
+
+- **Project Name:** Hackrx
+- **Python Version:** 3.13.3
+
+# 🚀 HackRx PDF RAG API
+
+A production-ready FastAPI service that processes PDF documents and answers questions using Retrieval-Augmented Generation (RAG) with Google's Gemini AI.
+
+## ✨ Features
+
+- 🔍 **PDF Processing**: Automatic extraction and chunking of PDF documents
+- 🧠 **AI-Powered Q&A**: Answers questions using Google's Gemini Pro 2.5
+- 📊 **Vector Search**: Fast similarity search using FAISS with sentence embeddings
+- 🔐 **Authentication**: Secure Bearer token authentication
+- ⚡ **Fast Response**: Sub-30 second response times
+- 🌐 **Public API**: HTTPS-ready for production deployment
+
+## 📋 API Endpoints
+
+### POST /hackrx/run
+Process a PDF document and answer questions.
+
+**Authentication**: Bearer Token Required
+
+**Request Format**:
+```json
+{
+  "documents": "https://example.com/document.pdf",
+  "questions": [
+    "What is the grace period for premium payment?",
+    "What is the waiting period for pre-existing diseases?"
+  ]
+}
+```
+
+**Response Format**:
+```json
+{
+  "answers": [
+    "A grace period of thirty days is provided...",
+    "There is a waiting period of thirty-six months..."
+  ]
+}
+```
+
+### GET /health
+Health check endpoint for monitoring.
+
+## 🛠️ Installation
+
+### Prerequisites
+- Python 3.8+
+- pip package manager
+- 4GB+ RAM recommended
+
+### 1. Clone and Setup
+```bash
+git clone <your-repo-url>
+cd hackrx-pdf-rag-api
+```
+
+### 2. Create Virtual Environment
+```bash
+# Windows
+python -m venv venv
+venv\\Scripts\\activate
+
+# Linux/Mac
+python3 -m venv venv
+source venv/bin/activate
+```
+
+### 3. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Environment Configuration
+Create a `.env` file:
+```bash
+# API Configuration
+API_KEY=hackrx-2025-secure-key
+
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+DEBUG=False
+```
+
+### 5. Run the Application
+
+#### Local Development
+```bash
+# Run with auto-reload
+python fastapi_app.py
+
+# Or with uvicorn
+uvicorn fastapi_app:app --reload --host 0.0.0.0 --port 8000
+```
+
+#### Production with HTTPS
+```bash
+# With SSL certificates
+uvicorn fastapi_app:app --host 0.0.0.0 --port 443 \
+  --ssl-keyfile=path/to/key.pem \
+  --ssl-certfile=path/to/cert.pem
+```
+
+## 🚀 Deployment Options
+
+### Option 1: Render (Recommended)
+1. Create account at [render.com](https://render.com)
+2. Connect GitHub repository
+3. Use `render.yaml` configuration
+4. Deploy automatically
+
+### Option 2: Railway
+```bash
+# Install Railway CLI
+npm install -g @railway/cli
+
+# Deploy
+railway login
+railway up
+```
+
+### Option 3: Heroku
+```bash
+# Install Heroku CLI
+heroku create hackrx-pdf-rag-api
+git push heroku main
+```
+
+### Option 4: Docker
+```bash
+# Build image
+docker build -t hackrx-pdf-rag .
+
+# Run container
+docker run -p 8000:8000 hackrx-pdf-rag
+```
+
+## 📖 Usage Examples
+
+### 1. Testing with curl
+```bash
+curl -X POST "http://localhost:8000/hackrx/run" \\
+  -H "Authorization: Bearer hackrx-2024-secure-key" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "documents": "https://hackrx.blob.core.windows.net/assets/policy.pdf?sv=2023-01-03&st=2025-07-04T09%3A11%3A24Z&se=2027-07-05T09%3A11%3A00Z&sr=b&sp=r&sig=N4a9OU0w0QXO6AOIBiu4bpl7AXvEZogeT%2FjUHNO7HzQ%3D",
+    "questions": [
+      "What is the grace period for premium payment?",
+      "What is the waiting period for pre-existing diseases?"
+    ]
+  }'
+```
+
+### 2. Python Client
+```python
+import requests
+
+API_URL = "https://your-domain.com/hackrx/run"
+API_KEY = "hackrx-2024-secure-key"
+
+response = requests.post(
+    API_URL,
+    headers={
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json"
+    },
+    json={
+        "documents": "https://example.com/document.pdf",
+        "questions": [
+            "What is the grace period for premium payment?",
+            "What is the waiting period for pre-existing diseases?",
+            "Does this policy cover maternity expenses?",
+            "What is the waiting period for cataract surgery?",
+            "Are the medical expenses for an organ donor covered?",
+            "What is the No Claim Discount (NCD) offered?",
+            "Is there a benefit for preventive health check-ups?",
+            "How does the policy define a 'Hospital'?",
+            "What is the extent of coverage for AYUSH treatments?",
+            "Are there any sub-limits on room rent and ICU charges?"
+        ]
+    }
+)
+
+print(response.json())
+```
+
+### 3. JavaScript/Node.js
+```javascript
+const axios = require('axios');
+
+async function processDocument() {
+  const response = await axios.post('https://your-domain.com/hackrx/run', {
+    documents: 'https://example.com/document.pdf',
+    questions: [
+      'What is the grace period for premium payment?',
+      'What is the waiting period for pre-existing diseases?'
+    ]
+  }, {
+    headers: {
+      'Authorization': 'Bearer hackrx-2024-secure-key',
+      'Content-Type': 'application/json'
+    }
+  });
+  
+  console.log(response.data);
+}
+
+processDocument();
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `API_KEY` | Bearer token for authentication | `hackrx-2024-secure-key` |
+| `GEMINI_API_KEY` | Google Gemini API key | Provided |
+| `HOST` | Server host | `0.0.0.0` |
+| `PORT` | Server port | `8000` |
+| `DEBUG` | Debug mode | `False` |
+
+### Performance Tuning
+- **Memory**: Ensure 4GB+ RAM for large PDFs
+- **Timeout**: Set to 30 seconds for optimal performance
+- **Concurrency**: Supports multiple simultaneous requests
+
+## 🧪 Testing
+
+### Run Tests
+```bash
+# Install test dependencies
+pip install pytest pytest-asyncio httpx
+
+# Run tests
+pytest test_api.py -v
+```
+
+### Load Testing
+```bash
+# Install locust
+pip install locust
+
+# Run load test
+locust -f load_test.py --host=http://localhost:8000
+```
+
+## 📊 Monitoring
+
+### Health Check
+```bash
+curl http://localhost:8000/health
+```
+
+### Logging
+- Logs are written to stdout
+- Use `docker logs` for containerized deployments
+- Integrate with monitoring tools like Datadog or New Relic
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+1. **PDF Download Fails**
+   - Check URL accessibility
+   - Verify file format (PDF only)
+   - Ensure HTTPS URLs for production
+
+2. **Slow Response Times**
+   - Increase server resources
+   - Optimize PDF size (< 10MB recommended)
+   - Check network connectivity
+
+3. **Authentication Errors**
+   - Verify Bearer token format
+   - Check API key in environment variables
+
+4. **Memory Issues**
+   - Monitor RAM usage during processing
+   - Consider PDF size limits
+   - Use streaming for large files
+
+### Debug Mode
+```bash
+# Enable debug logging
+DEBUG=True python fastapi_app.py
+```
+
+## 🏗️ Architecture

app/config/config.json

@@ -0,0 +1,12 @@
+{
+  "MODEL_NAME": "llama-3.3-70b-versatile",
+  "GROQ_KEY": "",
+  "VALID_API_KEY": "2931609bd36ec1a45cb577b3b831dc711c76ae157b3c6250c564284c93b062ff",
+
+  "LLM_CONFIG": {
+    "TEMPERATURE": 0.7,
+    "MAX_TOKENS": 300,
+    "FREQUENCY_PENALTY": 0,
+    "PRESENCE_PENALTY": 0
+  }
+}

app/core/models.py

@@ -0,0 +1,136 @@
+
+import os
+import logging
+import time
+import asyncio
+
+from fastapi import status
+from langchain_groq import ChatGroq
+from langchain.schema import Document
+from langchain.chains import RetrievalQA
+from langchain_community.vectorstores import FAISS
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_text_splitters import CharacterTextSplitter, RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from app.core.template import prompt_template_description
+
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# Async PDF loader
+async def pdf_loader(url: str):
+    pages = []
+    loader = PyPDFLoader(url)
+    async for page in loader.alazy_load():
+        pages.append(page)
+    
+    return pages
+
+# Main function to create/load vectorstore
+async def load_and_create_vector_store(url: str):
+    """
+    Loads a PDF document from a URL and either reuses or builds a FAISS vectorstore.
+    Returns a retriever object.
+    """
+    vectorstore_path = "./database/faiss_index"
+
+    if os.path.exists(f"{vectorstore_path}/index.faiss"):
+        logging.info("Vector store already exists, loading it.")
+        vectorstore = FAISS.load_local(vectorstore_path, embeddings, allow_dangerous_deserialization=True)
+    else:
+        logging.info("Vector store not found. Creating new one from document.")
+        pages = await pdf_loader(url)
+        if not pages:
+            raise ValueError("No pages loaded from the document.")
+        
+        full_text = "\n\n".join([page.page_content for page in pages])
+        documents = [Document(page_content=full_text, metadata={"source": url})]
+        # Use CharacterTextSplitter with optimized parameters for better chunk quality
+        text_splitter = CharacterTextSplitter(
+            separator="\n\n",
+            chunk_size=2500,
+            chunk_overlap=300,
+            length_function=len,
+        )
+        split_docs = text_splitter.split_documents(documents)
+        logging.info(f"Document split into {len(split_docs)} chunks")
+
+        vectorstore = FAISS.from_documents(split_docs, embeddings)
+        vectorstore.save_local(vectorstore_path)
+
+    return vectorstore.as_retriever(
+        search_kwargs={"k": 2, "score_threshold": 0.5}
+    )
+
+async def llm_setup(config, url):
+    """
+    Setup the LLM for question answering.
+    
+    This function initializes the LLM with the necessary configurations
+    for processing questions and generating answers based on the context.
+    
+    Args:
+        config: Configuration dictionary with LLM settings
+        url: URL of the document to process
+    Returns:
+        object: The configured LLM instance.
+    """
+    llm = ChatGroq(
+        model=f"{config.get('MODEL_NAME')}",
+        temperature=f"{config.get('TEMPERATURE', 0)}",
+        max_tokens=f"{config.get('MAX_TOKENS', 300)}",  # Increased token limit for JSON responses
+        max_retries=f"{config.get('MAX_RETRIES', 3)}",
+        api_key=f"{config.get('GROQ_KEY')}",
+    )
+    logging.info(f"LLM initialized with model: {config.get('MODEL_NAME')}, api_key: {config.get('GROQ_KEY')}")
+
+    # Choose template based on whether we need structured JSON output
+    prompt_template = prompt_template_description()
+
+    retriever = await load_and_create_vector_store(url=url)
+
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=retriever,
+        chain_type_kwargs={"prompt": prompt_template}
+    )
+    return qa_chain
+
+async def llm_response_generator(config, url, questions):
+    """
+    Generate answers from the LLM within 30 seconds.
+    
+    Args:
+        config: Configuration dictionary with LLM settings
+        url: URL of the document to process
+        questions: List of questions to answer
+        use_json: Whether to force JSON output format
+        
+    Returns:
+        Tuple of (response dict, status code)
+    """
+    try:
+        start = time.time()
+        qa_chain = await llm_setup(config, url)
+
+        answers = []
+        for question in questions:
+            elapsed = time.time() - start
+            if elapsed > 28:  # leave margin for safety
+                logging.warning("Time limit reached, skipping remaining questions.")
+                break
+
+            try:
+                answer = await qa_chain.arun(question)
+                answers.append(answer)
+            
+            except Exception as e:
+                logging.error(f"Error answering: {question} | {e}")
+                answers.append("Error processing question.")
+
+        return {"answers": answers}, status.HTTP_200_OK
+    
+    except Exception as e:
+        logging.error(f"Error in llm_response_generator: {e}")
+        return {"answers": []}, status.HTTP_500_INTERNAL_SERVER_ERROR

app/core/template.py

@@ -0,0 +1,27 @@
+from langchain.prompts import PromptTemplate
+
+
+def prompt_template_description():
+    """
+    Returns a clean and usable prompt template.
+    """
+    template = """You are a specialized AI assistant designed to provide precise, factual answers based strictly on the context of the provided document. These documents may include insurance policies, legal contracts, HR manuals, compliance guidelines, technical manuals, brochures, academic materials, or other large, unstructured texts.
+
+CRITICAL RULES:
+- Answer exactly what is asked with the most important details only
+- Include specific numbers, time periods, names, or key conditions when relevant
+- Keep answers to 1-2 sentences maximum
+- Use clear, professional language
+- Focus on the core information requested
+- If information is not in the context, respond with: "Information not available in the provided document."
+
+IMPORTANT: Respond with ONLY the answer text. Do NOT wrap your response in JSON format. Do not mention page numbers or sources. Provide a focused answer with only the essential details from the document that directly answer the question.
+
+Context:
+{context}
+
+Question:
+{question}
+
+Answer:"""
+    return PromptTemplate.from_template(template)

app/schema/schema.py

@@ -0,0 +1,10 @@
+from typing import List, Optional
+from pydantic import BaseModel, HttpUrl
+
+
+class QuestionRequest(BaseModel):
+    documents: HttpUrl
+    questions: List[str]
+
+class AnswerResponse(BaseModel):
+    answers: List[str]

app/utils/util.py

@@ -0,0 +1,40 @@
+
+import re
+import json
+import logging
+from fastapi import FastAPI, HTTPException, Depends, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+security = HTTPBearer()
+
+def load_config():
+    """
+    Load configuration from config.json.
+    """
+    with open('./app/config/config.json', 'r') as file:
+        config_data = json.load(file)
+    print(config_data)
+    logging.info("Configuration loaded successfully.")
+    return config_data
+
+
+def verify_api_key(credentials: HTTPAuthorizationCredentials = Security(security)):
+    """
+    Verify the API key from Bearer token
+    """
+    config = load_config()
+    if credentials.credentials != config.get("VALID_API_KEY"):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API Key"
+        )
+    
+    logging.info("API Key verified successfully.")
+    return credentials.credentials
+
+
+def sanitize_filename(file_link: str) -> str:
+    """
+    Sanitize file link to create a safe filename.
+    """
+    return re.sub(r'[^a-zA-Z0-9_-]', '_', file_link)

main.py

@@ -0,0 +1,88 @@
+import os
+import logging
+import uvicorn
+import json
+import hashlib
+
+# Import our existing pipeline components
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException, Depends, status
+from app.utils.util import verify_api_key
+from app.core.models import llm_response_generator
+from app.schema.schema import QuestionRequest, AnswerResponse
+
+logging.basicConfig(format='%(asctime)s - %(levelname)s - Line: %(lineno)d - %(message)s', 
+                    datefmt='%Y-%m-%d %H:%M:%S', 
+                    level=logging.INFO)
+
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Load config.json at startup
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    import json
+    config_path = os.path.join(os.path.dirname(__file__), "app", "config", "config.json")
+    with open(config_path, "r") as f:
+        app.state.config = json.load(f)
+    logging.info("Config loaded successfully.")
+    yield
+    logging.info("Shutting down FastAPI app...")
+
+
+# FastAPI app
+app = FastAPI(title="HackRx PDF RAG API", version="1.0.0", lifespan=lifespan)
+
+@app.post("/api/v1/hackrx/run", response_model=AnswerResponse)
+async def process_questions(request: QuestionRequest, api_key: str = Depends(verify_api_key)):
+    try:
+        url = str(request.documents)
+        config = app.state.config
+        questions = request.questions
+
+        logging.info(f"Received {len(questions)} questions for processing. Documents URL: {url}")
+
+        # Create cache directory if not exists
+        cache_dir = "redis"
+        os.makedirs(cache_dir, exist_ok=True)
+        # Create a cache key from url and questions
+        cache_key = hashlib.sha256((url + json.dumps(questions, sort_keys=True)).encode()).hexdigest()
+        cache_file = os.path.join(cache_dir, f"{cache_key}.json")
+
+        # Try to load from cache
+        if os.path.exists(cache_file):
+            logging.info(f"Cache hit for key: {cache_key}")
+            with open(cache_file, "r") as f:
+                cached_response = json.load(f)
+            return cached_response
+
+        # Otherwise, call LLM and cache response
+        response, status_code = await llm_response_generator(config=config, url=url, questions=questions)
+        if status_code != status.HTTP_200_OK:
+            raise HTTPException(status_code=status_code, detail="Error processing questions")
+        
+        else:
+            with open(cache_file, "w") as f:
+                json.dump(response, f)
+            logging.info(f"Cache saved for key: {cache_key}")
+            return response
+
+    except Exception as e:
+        logging.error(f"Error processing questions: {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+@app.get("/health")
+async def health_check():
+    """
+    Health check endpoint to verify API is running
+    """
+    return {"status": "Healthy", "message": "API is running smoothly.", "code": status.HTTP_200_OK}
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        workers=1
+    )

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+pypdf
+langchain_community
+uvicorn
+langchain_groq
+sentence-transformers
+langchain-huggingface
+faiss-cpu
+langchain-text-splitters