Add application file

.dockerignore

@@ -0,0 +1,26 @@
+.git
+.gitignore
+README.md
+DEPLOYMENT.md
+render.yaml
+start.sh
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis 

.gitignore

@@ -0,0 +1,61 @@
+# Environment variables
+.env
+.env.local
+.env.production
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+*.temp
+
+# FAISS index files
+*.index
+*.faiss
+
+# PDF files (if you don't want to commit them)
+*.pdf 
+
+DEPLOYMENT.md

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"] 

HUGGINGFACE_DEPLOYMENT.md

@@ -0,0 +1,112 @@
+# Hugging Face Spaces Deployment Guide
+
+This guide will help you deploy your HackRx Insurance Policy Assistant to Hugging Face Spaces.
+
+## Prerequisites
+
+1. A Hugging Face account (free at https://huggingface.co)
+2. A Google Gemini API key
+3. Your code pushed to a Git repository (GitHub, GitLab, etc.)
+
+## Step 1: Prepare Your Repository
+
+Your repository should contain the following files:
+- `app.py` - Main application entry point
+- `Dockerfile` - Docker configuration
+- `requirements.txt` - Python dependencies
+- `parser.py`, `embedder.py`, `retriever.py`, `llm.py` - Application modules
+- `.dockerignore` - Docker build optimization
+
+## Step 2: Create a Hugging Face Space
+
+1. Go to https://huggingface.co/spaces
+2. Click "Create new Space"
+3. Choose the following settings:
+   - **Owner**: Your username
+   - **Space name**: `hackrx-insurance-assistant` (or your preferred name)
+   - **Space SDK**: `Docker`
+   - **License**: Choose appropriate license
+   - **Visibility**: Public or Private (your choice)
+
+## Step 3: Connect Your Repository
+
+1. In your new Space, go to the "Settings" tab
+2. Under "Repository", click "Connect to existing repository"
+3. Select your Git provider (GitHub, GitLab, etc.)
+4. Choose your repository
+5. Click "Connect"
+
+## Step 4: Configure Environment Variables
+
+1. In your Space settings, go to the "Repository secrets" section
+2. Add the following secret:
+   - **Name**: `GOOGLE_API_KEY`
+   - **Value**: Your Google Gemini API key
+
+## Step 5: Deploy
+
+1. Push your code to your Git repository
+2. Hugging Face Spaces will automatically detect the changes and start building
+3. You can monitor the build progress in the "Logs" tab
+4. Once built successfully, your API will be available at `https://your-space-name.hf.space`
+
+## Step 6: Test Your Deployment
+
+### Health Check
+```bash
+curl https://your-space-name.hf.space/
+```
+
+### Test API Endpoint
+```bash
+curl -X POST https://your-space-name.hf.space/api/v1/hackrx/run \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_token_here" \
+  -d '{
+    "documents": "https://example.com/insurance-policy.pdf",
+    "questions": ["What is the coverage amount?"]
+  }'
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Build Fails**: Check the logs in the "Logs" tab for error messages
+2. **Environment Variable Not Set**: Ensure `GOOGLE_API_KEY` is set in Space secrets
+3. **Port Issues**: The application runs on port 7860 (default for Hugging Face Spaces)
+4. **Memory Issues**: If you encounter memory issues, consider optimizing the Dockerfile
+
+### Debugging
+
+1. Check the build logs in the "Logs" tab
+2. Monitor the application logs for runtime errors
+3. Test locally first to ensure everything works
+
+## API Documentation
+
+Once deployed, your API will have the following endpoints:
+
+- `GET /` - Health check
+- `GET /health` - API status
+- `POST /api/v1/hackrx/run` - Process PDF from URL
+- `POST /api/v1/hackrx/local` - Process local PDF file
+
+## Cost Considerations
+
+- Hugging Face Spaces offers free hosting for public spaces
+- Private spaces may have usage limits
+- Consider the cost of Google Gemini API calls
+
+## Security Notes
+
+- Keep your API keys secure
+- Use appropriate authentication for production use
+- Consider rate limiting for public APIs
+
+## Updates
+
+To update your deployment:
+1. Push changes to your Git repository
+2. Hugging Face Spaces will automatically rebuild and deploy
+3. Monitor the build process in the "Logs" tab 

README_HF.md

@@ -0,0 +1,112 @@
+# HackRx Insurance Policy Assistant
+
+A FastAPI application that processes PDF documents and answers questions using AI, deployed on Hugging Face Spaces.
+
+## Features
+
+- PDF document parsing and text extraction
+- Vector-based document search using FAISS
+- AI-powered question answering using Google Gemini
+- RESTful API endpoints for document processing
+
+## API Endpoints
+
+### Health Check
+- `GET /` - Root endpoint
+- `GET /health` - API status check
+
+### Process PDF from URL
+- `POST /api/v1/hackrx/run`
+- **Headers**: `Authorization: Bearer <your_token>`
+- **Body**:
+```json
+{
+  "documents": "https://example.com/document.pdf",
+  "questions": ["What is the coverage amount?", "What are the exclusions?"]
+}
+```
+
+### Process Local PDF File
+- `POST /api/v1/hackrx/local`
+- **Body**:
+```json
+{
+  "document_path": "/app/files/document.pdf",
+  "questions": ["What is the coverage amount?", "What are the exclusions?"]
+}
+```
+
+## Environment Variables
+
+Set these in your Hugging Face Space settings:
+
+- `GOOGLE_API_KEY` - Your Google Gemini API key
+
+## Usage Examples
+
+### Using curl
+
+```bash
+# Health check
+curl https://your-space-name.hf.space/
+
+# Process PDF from URL
+curl -X POST https://your-space-name.hf.space/api/v1/hackrx/run \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_token_here" \
+  -d '{
+    "documents": "https://example.com/insurance-policy.pdf",
+    "questions": ["What is the coverage amount?", "What are the exclusions?"]
+  }'
+```
+
+### Using Python
+
+```python
+import requests
+
+# Health check
+response = requests.get("https://your-space-name.hf.space/")
+print(response.json())
+
+# Process PDF
+url = "https://your-space-name.hf.space/api/v1/hackrx/run"
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": "Bearer your_token_here"
+}
+data = {
+    "documents": "https://example.com/insurance-policy.pdf",
+    "questions": ["What is the coverage amount?", "What are the exclusions?"]
+}
+
+response = requests.post(url, headers=headers, json=data)
+print(response.json())
+```
+
+## Local Development
+
+To run the application locally:
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+The API will be available at `http://localhost:7860`
+
+## Deployment
+
+This application is configured for deployment on Hugging Face Spaces using Docker. The following files are included:
+
+- `app.py` - Main application entry point
+- `Dockerfile` - Docker configuration
+- `.dockerignore` - Docker build optimization
+- `requirements.txt` - Python dependencies
+
+## Model Information
+
+- **Framework**: FastAPI
+- **AI Model**: Google Gemini
+- **Vector Database**: FAISS
+- **Document Processing**: PyMuPDF 

app.py

@@ -0,0 +1,150 @@
+import os
+import warnings
+import logging
+
+# Suppress TensorFlow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+os.environ['TF_LOGGING_LEVEL'] = 'ERROR'
+os.environ['TF_ENABLE_DEPRECATION_WARNINGS'] = '0'
+
+# Suppress specific TensorFlow deprecation warnings
+warnings.filterwarnings('ignore', category=DeprecationWarning, module='tensorflow')
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+
+from fastapi import FastAPI, Request, HTTPException, Depends, Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from parser import parse_pdf_from_url, parse_pdf_from_file
+from embedder import build_faiss_index
+from retriever import retrieve_chunks
+from llm import query_gemini
+import uvicorn
+
+app = FastAPI(title="HackRx Insurance Policy Assistant", version="1.0.0")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {"message": "HackRx Insurance Policy Assistant API is running!"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "message": "API is ready to process requests"}
+
+class QueryRequest(BaseModel):
+    documents: str
+    questions: list[str]
+
+class LocalQueryRequest(BaseModel):
+    document_path: str
+    questions: list[str]
+
+def verify_token(authorization: str = Header(None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Invalid authorization header")
+    
+    token = authorization.replace("Bearer ", "")
+    # For demo purposes, accept any token. In production, validate against a database
+    if not token:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+    return token
+
+@app.post("/api/v1/hackrx/run")
+async def run_query(request: QueryRequest, token: str = Depends(verify_token)):
+    try:
+        print(f"Processing {len(request.questions)} questions...")
+        
+        text_chunks = parse_pdf_from_url(request.documents)
+        print(f"Extracted {len(text_chunks)} text chunks from PDF")
+        
+        index, texts = build_faiss_index(text_chunks)
+        
+        # Get relevant chunks for all questions at once
+        all_chunks = set()
+        for question in request.questions:
+            top_chunks = retrieve_chunks(index, texts, question)
+            all_chunks.update(top_chunks)
+        
+        # Process all questions in a single LLM call
+        print(f"Processing all {len(request.questions)} questions in batch...")
+        response = query_gemini(request.questions, list(all_chunks))
+        
+        # Extract answers from the JSON response
+        if isinstance(response, dict) and "answers" in response:
+            answers = response["answers"]
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        else:
+            # Fallback if response is not in expected format
+            answers = [response] if isinstance(response, str) else []
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        
+        print(f"Generated {len(answers)} answers")
+        return { "answers": answers }
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@app.post("/api/v1/hackrx/local")
+async def run_local_query(request: LocalQueryRequest):
+    try:
+        print(f"Processing local document: {request.document_path}")
+        print(f"Processing {len(request.questions)} questions...")
+        
+        # Parse local PDF file
+        text_chunks = parse_pdf_from_file(request.document_path)
+        print(f"Extracted {len(text_chunks)} text chunks from local PDF")
+        
+        index, texts = build_faiss_index(text_chunks)
+        
+        # Get relevant chunks for all questions at once
+        all_chunks = set()
+        for question in request.questions:
+            top_chunks = retrieve_chunks(index, texts, question)
+            all_chunks.update(top_chunks)
+        
+        # Process all questions in a single LLM call
+        print(f"Processing all {len(request.questions)} questions in batch...")
+        response = query_gemini(request.questions, list(all_chunks))
+        
+        # Extract answers from the JSON response
+        if isinstance(response, dict) and "answers" in response:
+            answers = response["answers"]
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        else:
+            # Fallback if response is not in expected format
+            answers = [response] if isinstance(response, str) else []
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        
+        print(f"Generated {len(answers)} answers")
+        return { "answers": answers }
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run("app:app", host="0.0.0.0", port=port) 

embedder.py

@@ -0,0 +1,12 @@
+import faiss
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+def build_faiss_index(chunks):
+    embeddings = model.encode(chunks)
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatL2(dimension)
+    index.add(np.array(embeddings))
+    return index, chunks

llm.py

@@ -0,0 +1,69 @@
+import google.generativeai as genai
+import os
+import json
+from dotenv import load_dotenv
+load_dotenv()
+
+api_key = os.getenv("GOOGLE_API_KEY")
+if not api_key:
+    raise ValueError("GOOGLE_API_KEY environment variable is not set. Please add it to your .env file")
+
+print(f"Google API Key loaded: {api_key[:10]}..." if api_key else "No API key found")
+genai.configure(api_key=api_key)
+
+def query_gemini(questions, contexts):
+    try:
+        context = "\n\n".join(contexts)
+        
+        # Create a numbered list of questions
+        questions_text = "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])
+        
+        prompt = f"""You are an insurance policy assistant. Based on the below document snippets, answer the following questions precisely.
+
+IMPORTANT INSTRUCTIONS:
+1. Only respond based on the context provided. If information is not found in the context, respond with "Not Found".
+2. Provide clear, concise answers that directly address each question.
+3. Return your response in the exact JSON format shown below.
+4. Give complete, informative responses based on the provided context.
+5. Answer each question in the order provided.
+
+Context:
+{context}
+
+Questions:
+{questions_text}
+
+Return your response in this exact JSON format:
+{{
+    "answers": [
+        "Answer to question 1",
+        "Answer to question 2",
+        "Answer to question 3",
+        ...
+    ]
+}}
+
+Ensure each answer is comprehensive and directly addresses the corresponding question. If information is not found in the context for any question, respond with "Not Found" for that question."""
+
+        model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        response = model.generate_content(prompt)
+        response_text = response.text.strip()
+        
+        # Try to parse the response as JSON
+        try:
+            # Remove any markdown code blocks if present
+            if response_text.startswith("```json"):
+                response_text = response_text.replace("```json", "").replace("```", "").strip()
+            elif response_text.startswith("```"):
+                response_text = response_text.replace("```", "").strip()
+            
+            parsed_response = json.loads(response_text)
+            return parsed_response
+        except json.JSONDecodeError:
+            # If JSON parsing fails, return a structured response
+            print(f"Failed to parse JSON response: {response_text}")
+            return {"answers": ["Error parsing response"] * len(questions)}
+            
+    except Exception as e:
+        print(f"Error in query_gemini: {str(e)}")
+        return {"answers": [f"Error generating response: {str(e)}"] * len(questions)}

main.py

@@ -0,0 +1,151 @@
+import os
+import warnings
+import logging
+
+# Suppress TensorFlow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+os.environ['TF_LOGGING_LEVEL'] = 'ERROR'
+os.environ['TF_ENABLE_DEPRECATION_WARNINGS'] = '0'
+
+# Suppress specific TensorFlow deprecation warnings
+warnings.filterwarnings('ignore', category=DeprecationWarning, module='tensorflow')
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+
+from fastapi import FastAPI, Request, HTTPException, Depends, Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from parser import parse_pdf_from_url, parse_pdf_from_file
+from embedder import build_faiss_index
+from retriever import retrieve_chunks
+from llm import query_gemini
+import uvicorn
+
+app = FastAPI(title="HackRx Insurance Policy Assistant", version="1.0.0")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {"message": "HackRx Insurance Policy Assistant API is running!"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "message": "API is ready to process requests"}
+
+class QueryRequest(BaseModel):
+    documents: str
+    questions: list[str]
+
+class LocalQueryRequest(BaseModel):
+    document_path: str
+    questions: list[str]
+
+def verify_token(authorization: str = Header(None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Invalid authorization header")
+    
+    token = authorization.replace("Bearer ", "")
+    # For demo purposes, accept any token. In production, validate against a database
+    if not token:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+    return token
+
+@app.post("/api/v1/hackrx/run")
+async def run_query(request: QueryRequest, token: str = Depends(verify_token)):
+    try:
+        print(f"Processing {len(request.questions)} questions...")
+        
+        text_chunks = parse_pdf_from_url(request.documents)
+        print(f"Extracted {len(text_chunks)} text chunks from PDF")
+        
+        index, texts = build_faiss_index(text_chunks)
+        
+        # Get relevant chunks for all questions at once
+        all_chunks = set()
+        for question in request.questions:
+            top_chunks = retrieve_chunks(index, texts, question)
+            all_chunks.update(top_chunks)
+        
+        # Process all questions in a single LLM call
+        print(f"Processing all {len(request.questions)} questions in batch...")
+        response = query_gemini(request.questions, list(all_chunks))
+        
+        # Extract answers from the JSON response
+        if isinstance(response, dict) and "answers" in response:
+            answers = response["answers"]
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        else:
+            # Fallback if response is not in expected format
+            answers = [response] if isinstance(response, str) else []
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        
+        print(f"Generated {len(answers)} answers")
+        return { "answers": answers }
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@app.post("/api/v1/hackrx/local")
+async def run_local_query(request: LocalQueryRequest):
+    try:
+        print(f"Processing local document: {request.document_path}")
+        print(f"Processing {len(request.questions)} questions...")
+        
+        # Parse local PDF file
+        text_chunks = parse_pdf_from_file(request.document_path)
+        print(f"Extracted {len(text_chunks)} text chunks from local PDF")
+        
+        index, texts = build_faiss_index(text_chunks)
+        
+        # Get relevant chunks for all questions at once
+        all_chunks = set()
+        for question in request.questions:
+            top_chunks = retrieve_chunks(index, texts, question)
+            all_chunks.update(top_chunks)
+        
+        # Process all questions in a single LLM call
+        print(f"Processing all {len(request.questions)} questions in batch...")
+        response = query_gemini(request.questions, list(all_chunks))
+        
+        # Extract answers from the JSON response
+        if isinstance(response, dict) and "answers" in response:
+            answers = response["answers"]
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        else:
+            # Fallback if response is not in expected format
+            answers = [response] if isinstance(response, str) else []
+            # Ensure we have the right number of answers
+            while len(answers) < len(request.questions):
+                answers.append("Not Found")
+            answers = answers[:len(request.questions)]
+        
+        print(f"Generated {len(answers)} answers")
+        return { "answers": answers }
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 10000))
+    uvicorn.run("main:app", host="0.0.0.0", port=port)
+

parser.py

@@ -0,0 +1,27 @@
+import fitz  # PyMuPDF
+import requests
+from io import BytesIO
+
+def parse_pdf_from_url(url):
+    res = requests.get(url)
+    doc = fitz.open(stream=BytesIO(res.content), filetype="pdf")
+    chunks = []
+    for page in doc:
+        text = page.get_text()
+        if text.strip():
+            chunks.append(text)
+    return chunks
+
+def parse_pdf_from_file(file_path):
+    """Parse a local PDF file and extract text chunks"""
+    try:
+        doc = fitz.open(file_path)
+        chunks = []
+        for page in doc:
+            text = page.get_text()
+            if text.strip():
+                chunks.append(text)
+        doc.close()
+        return chunks
+    except Exception as e:
+        raise Exception(f"Error parsing PDF file {file_path}: {str(e)}")

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+requests
+faiss-cpu
+sentence-transformers
+PyMuPDF
+python-dotenv
+tf-keras
+google-generativeai
+

retriever.py

@@ -0,0 +1,9 @@
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+def retrieve_chunks(index, texts, query, k=5):
+    query_vec = model.encode([query])
+    distances, indices = index.search(np.array(query_vec), k)
+    return [texts[i] for i in indices[0]]

test_deployment.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Test script for Hugging Face Spaces deployment
+"""
+
+import requests
+import json
+import sys
+
+def test_health_check(base_url):
+    """Test the health check endpoint"""
+    try:
+        response = requests.get(f"{base_url}/")
+        print(f"Health check status: {response.status_code}")
+        print(f"Response: {response.json()}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"Health check failed: {e}")
+        return False
+
+def test_api_endpoint(base_url, api_key):
+    """Test the main API endpoint"""
+    try:
+        url = f"{base_url}/api/v1/hackrx/run"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+        data = {
+            "documents": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
+            "questions": ["What is this document about?"]
+        }
+        
+        response = requests.post(url, headers=headers, json=data)
+        print(f"API test status: {response.status_code}")
+        print(f"Response: {response.json()}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"API test failed: {e}")
+        return False
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python test_deployment.py <base_url> [api_key]")
+        print("Example: python test_deployment.py https://your-space-name.hf.space your_api_key")
+        sys.exit(1)
+    
+    base_url = sys.argv[1].rstrip('/')
+    api_key = sys.argv[2] if len(sys.argv) > 2 else "test_token"
+    
+    print(f"Testing deployment at: {base_url}")
+    print("=" * 50)
+    
+    # Test health check
+    print("1. Testing health check...")
+    health_ok = test_health_check(base_url)
+    
+    # Test API endpoint
+    print("\n2. Testing API endpoint...")
+    api_ok = test_api_endpoint(base_url, api_key)
+    
+    # Summary
+    print("\n" + "=" * 50)
+    print("DEPLOYMENT TEST SUMMARY")
+    print("=" * 50)
+    print(f"Health check: {'✅ PASS' if health_ok else '❌ FAIL'}")
+    print(f"API endpoint: {'✅ PASS' if api_ok else '❌ FAIL'}")
+    
+    if health_ok and api_ok:
+        print("\n🎉 Deployment is working correctly!")
+    else:
+        print("\n⚠️  Some tests failed. Check the logs above for details.")
+
+if __name__ == "__main__":
+    main()