Added the files adding system and formated the files system

Dockerfile

@@ -1,34 +0,0 @@
-# Use the latest slim Python 3.11 image
-FROM python:3.11-slim
-
-# Set environment variables
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    git \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create a non-root user for safety
-RUN useradd -ms /bin/bash user
-USER user
-WORKDIR $HOME/app
-
-# Copy app source code
-COPY --chown=user . .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir --upgrade pip \
- && pip install --no-cache-dir -r requirements.txt
-
-# Expose port
-EXPOSE 7860
-
-# Start the FastAPI app using uvicorn
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
-

MODEL/app.py

@@ -1,18 +0,0 @@
-import os
-from huggingface_hub import Repository
-
-
-def download_repo():
-    hf_token = os.getenv("HF_TOKEN")
-    if not hf_token:
-        raise ValueError("HF_TOKEN not found in environment variables.")
-
-    repo_id = "can-org/AIModel"
-    local_dir = "../Ai-Text-Detector/"
-
-    repo = Repository(local_dir, clone_from=repo_id, token=hf_token)
-    print(f"Repository downloaded to: {local_dir}")
-
-
-if __name__ == "__main__":
-    download_repo()

MODEL/readme.md

@@ -1,61 +0,0 @@
-### Hugging Face CLI Tool
-
-This CLI tool allows you to **upload** and **download** models from Hugging Face repositories. It requires an **Hugging Face Access Token (`HF_TOKEN`)** for authentication, especially for private repositories.
-
-### Prerequisites
-
-1. **Install Hugging Face Hub**:
-
-   ```bash
-   pip install huggingface_hub
-   ```
-
-2. **Get HF_TOKEN**:
-   - Log in to [Hugging Face](https://huggingface.co/).
-   - Go to **Settings** → **Access Tokens** → **Create a new token** with `read` and `write` permissions.
-   - Save the token.
-
-### Usage
-
-1. **Set the Token**:
-
-   - **Linux/macOS**:
-     ```bash
-     export HF_TOKEN=your_token_here
-     ```
-   - **Windows (CMD)**:
-     ```bash
-     set HF_TOKEN=your_token_here
-     ```
-
-2. **Download Model**:
-
-   ```bash
-   python main.py --download --repo-id <repo_name> --save-dir <local_save_path>
-   ```
-
-3. **Upload Model**:
-   ```bash
-   python main.py --upload --repo-id <repo_name> --model-path <local_model_path>
-   ```
-
-### Example
-
-To download a model:
-
-```bash
-python main.py
-```
-
-### Authentication
-
-Ensure you set `HF_TOKEN` to access private repositories. If not set, the script will raise an error.
-Here’s a clearer and more polished version of that note:
-
----
-
-### ⚠️ Note
-
-**Make sure to run this script from the `HuggingFace` directory to ensure correct path resolution and functionality.**
-
----

MODEL/requirements.txt

@@ -1 +0,0 @@
-huggingface_hub

Procfile

@@ -0,0 +1 @@
+web: uvicorn app:app --host 0.0.0.0 --port ${PORT:-8000}

README.md

@@ -1,268 +0,0 @@
-### **FastAPI AI**
-
-This FastAPI app loads a GPT-2 model, tokenizes input text, classifies it, and returns whether the text is AI-generated or human-written.
-
-### **install Dependencies**
-
-```bash
-pip install -r requirements.txt
-
-```
-
-This command installs all the dependencies listed in the `requirements.txt` file. It ensures that your environment has the required packages to run the project smoothly.
-
-**NOTE: IF YOU HAVE DONE ANY CHANGES DON'NT FORGOT TO PUT IT IN THE REQUIREMENTS.TXT USING `bash pip freeze > requirements.txt `**
-
----
-
-### **Functions**
-
-1. **`load_model()`**  
-   Loads the GPT-2 model and tokenizer from specified paths.
-
-2. **`lifespan()`**  
-   Manages the app's lifecycle: loads the model at startup and handles cleanup on shutdown.
-
-3. **`classify_text_sync()`**  
-   Synchronously tokenizes input text and classifies it using the GPT-2 model. Returns the classification and perplexity.
-
-4. **`classify_text()`**  
-   Asynchronously executes `classify_text_sync()` in a thread pool to ensure non-blocking processing.
-
-5. **`analyze_text()`**  
-   **POST** endpoint: accepts text input, classifies it using `classify_text()`, and returns the result with perplexity.
-
-6. **`health_check()`**  
-   **GET** endpoint: simple health check to confirm the API is running.
-
----
-
-### **Code Overview**
-
-### **Running and Load Balancing:**
-
-To run the app in production with load balancing:
-
-```bash
-uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
-```
-
-This command launches the FastAPI app.
-
-
-### **Endpoints**
-
-#### 1. **`/analyze`**
-
-- **Method:** `POST`
-- **Description:** Classifies whether the text is AI-generated or human-written.
-- **Request:**
-  ```json
-  { "text": "sample text" }
-  ```
-- **Response:**
-  ```json
-  { "result": "AI-generated", "perplexity": 55.67 }
-  ```
-
-#### 2. **`/health`**
-
-- **Method:** `GET`
-- **Description:** Returns the status of the API.
-- **Response:**
-  ```json
-  { "status": "ok" }
-  ```
-
----
-
-### **Running the API**
-
-Start the server with:
-
-```bash
-uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
-```
-
----
-
-### **🧪 Testing the API**
-
-You can test the FastAPI endpoint using `curl` like this:
-
-```bash
-curl -X POST https://can-org-canspace.hf.space/analyze \
-  -H "Authorization: Bearer SECRET_CODE" \
-  -H "Content-Type: application/json" \
-  -d '{"text": "This is a sample sentence for analysis."}'
-```
-
-- The `-H "Authorization: Bearer SECRET_CODE"` part is used to simulate the **handshake**.
-- FastAPI checks this token against the one loaded from the `.env` file.
-- If the token matches, the request is accepted and processed.
-- Otherwise, it responds with a `403 Unauthorized` error.
-
----
-
-### **API Documentation**
-
-- **Swagger UI:** `https://can-org-canspace.hf.space/docs` -> `/docs`
-- **ReDoc:** `https://can-org-canspace.hf.space/redoc` -> `/redoc`
-
-### **🔐 Handshake Mechanism**
-
-In this part, we're implementing a simple handshake to verify that the request is coming from a trusted source (e.g., our NestJS server). Here's how it works:
-
-- We load a secret token from the `.env` file.
-- When a request is made to the FastAPI server, we extract the `Authorization` header and compare it with our expected secret token.
-- If the token does **not** match, we immediately return a **403 Forbidden** response with the message `"Unauthorized"`.
-- If the token **does** match, we allow the request to proceed to the next step.
-
-The verification function looks like this:
-
-```python
-def verify_token(auth: str):
-    if auth != f"Bearer {EXPECTED_TOKEN}":
-        raise HTTPException(status_code=403, detail="Unauthorized")
-```
-
-This provides a basic but effective layer of security to prevent unauthorized access to the API.
-
-### **Implement it with NEST.js**
-
-NOTE: Make an micro service in NEST.JS and implement it there and call it from app.controller.ts
-
-in fastapi.service.ts file what we have done is
-
-### Project Structure
-
-```files
-nestjs-fastapi-bridge/
-├── src/
-│   ├── app.controller.ts
-│   ├── app.module.ts
-│   └── fastapi.service.ts
-├── .env
-
-```
-
----
-
-### Step-by-Step Setup
-
-#### 1. `.env`
-
-Create a `.env` file at the root with the following:
-
-```environment
-  FASTAPI_BASE_URL=https://can-org-canspace.hf.space/
-  SECRET_TOKEN="SECRET_CODE_TOKEN"
-```
-
-#### 2. `fastapi.service.ts`
-
-```javascript
-  // src/fastapi.service.ts
-  import { Injectable } from "@nestjs/common";
-  import { HttpService } from "@nestjs/axios";
-  import { ConfigService } from "@nestjs/config";
-  import { firstValueFrom } from "rxjs";
-
-  @Injectable()
-  export class FastAPIService {
-    constructor(
-      private http: HttpService,
-      private config: ConfigService,
-    ) {}
-
-    async analyzeText(text: string) {
-      const url = `${this.config.get("FASTAPI_BASE_URL")}/analyze`;
-      const token = this.config.get("SECRET_TOKEN");
-
-      const response = await firstValueFrom(
-        this.http.post(
-          url,
-          { text },
-          {
-            headers: {
-              Authorization: `Bearer ${token}`,
-            },
-          },
-        ),
-      );
-
-      return response.data;
-    }
-  }
-```
-
-#### 3. `app.module.ts`
-
-```javascript
-// src/app.module.ts
-import { Module } from "@nestjs/common";
-import { ConfigModule } from "@nestjs/config";
-import { HttpModule } from "@nestjs/axios";
-import { AppController } from "./app.controller";
-import { FastAPIService } from "./fastapi.service";
-
-@Module({
-  imports: [ConfigModule.forRoot(), HttpModule],
-  controllers: [AppController],
-  providers: [FastAPIService],
-})
-export class AppModule {}
-```
-
----
-
-#### 4. `app.controller.ts`
-
-```javascript
-  // src/app.controller.ts
-  import { Body, Controller, Post, Get, Query } from '@nestjs/common';
-  import { FastAPIService } from './fastapi.service';
-
-  @Controller()
-  export class AppController {
-    constructor(private readonly fastapiService: FastAPIService) {}
-
-    @Post('analyze-text')
-    async callFastAPI(@Body('text') text: string) {
-      return this.fastapiService.analyzeText(text);
-    }
-
-    @Get()
-    getHello(): string {
-      return 'NestJS is connected to FastAPI ';
-    }
-  }
-```
-
-### 🚀 How to Run
-
-Run the server of flask and nest.js:
-
-- for nest.js
-  ```bash
-  npm run start
-  ```
-- for Fastapi
-
-  ```bash
-  uvicorn app:app --reload
-  ```
-
-Make sure your FastAPI service is running at `http://localhost:8000`.
-
-### Test with CURL
-http://localhost:3000/-> Server of nest.js
-```bash
-curl -X POST http://localhost:3000/analyze-text \
-  -H 'Content-Type: application/json' \
-  -d '{"text": "This is a test input"}'
-```
-
-
-### MODEL 
-- You can download the model from the `/MODEL/app.py` file.

app.py

@@ -1,102 +1,20 @@
-from fastapi import FastAPI, HTTPException, Depends
-from fastapi.security import HTTPBearer
-from pydantic import BaseModel
-from transformers import GPT2LMHeadModel, GPT2TokenizerFast, GPT2Config
-import torch
-import asyncio
+from fastapi import FastAPI
 from contextlib import asynccontextmanager
+from features.text_classifier.routes import router as text_classifier_router
+from features.text_classifier.model_loader import warmup
 
-# FastAPI app instance
-app = FastAPI()
-
-# Global model and tokenizer variables
-model, tokenizer = None, None
-
-# HTTPBearer instance for security
-bearer_scheme = HTTPBearer()
-
-# Function to load model and tokenizer
-def load_model():
-    model_path = "./Ai-Text-Detector/model"
-    weights_path = "./Ai-Text-Detector/model_weights.pth"
 
-    try:
-        tokenizer = GPT2TokenizerFast.from_pretrained(model_path)
-        config = GPT2Config.from_pretrained(model_path)
-        model = GPT2LMHeadModel(config)
-        model.load_state_dict(torch.load(weights_path, map_location=torch.device("cpu")))
-        model.eval() 
-    except Exception as e:
-        raise RuntimeError(f"Error loading model: {str(e)}")
-
-    return model, tokenizer
-
-# Load model on app startup
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    global model, tokenizer
-    model, tokenizer = load_model()
+    warmup()  # Download and load model at startup
     yield
+    # Cleanup lo
 
-# Attach startup loader
-app = FastAPI(lifespan=lifespan)
-
-# Input schema
-class TextInput(BaseModel):
-    text: str
-
-# Sync text classification
-def classify_text(sentence: str):
-    inputs = tokenizer(sentence, return_tensors="pt", truncation=True, padding=True)
-    input_ids = inputs["input_ids"]
-    attention_mask = inputs["attention_mask"]
 
-    with torch.no_grad():
-        outputs = model(input_ids, attention_mask=attention_mask, labels=input_ids)
-        loss = outputs.loss
-        perplexity = torch.exp(loss).item()
-
-    if perplexity < 60:
-        result = "AI-generated"
-    elif perplexity < 80:
-        result = "Probably AI-generated"
-    else:
-        result = "Human-written"
-
-    return result, perplexity
-
-# POST route to analyze text with Bearer token
-@app.post("/analyze")
-async def analyze_text(data: TextInput, token: str = Depends(bearer_scheme)):
-    user_input = data.text.strip()
-
-    if not user_input:
-        raise HTTPException(status_code=400, detail="Text cannot be empty")
-    
-    # Check if there are at least two words
-    word_count = len(user_input.split())
-    if word_count < 2:
-        raise HTTPException(status_code=400, detail="Text must contain at least two words")
-
-
-    result, perplexity = await asyncio.to_thread(classify_text, user_input)
-    
-    return {
-        "result": result,
-        "perplexity": round(perplexity, 2),
-    }
+app = FastAPI()
+app.include_router(text_classifier_router, prefix="/text", tags=["Text Classification"])
 
-# Health check route
-@app.get("/health")
-async def health_check():
-    return {"status": "ok"}
 
-# Simple index route
 @app.get("/")
 def index():
-    return {
-        "message": "FastAPI API is up.",
-        "try": "/docs to test the API.",
-        "status": "OK"
-    }
-
+    return {"Message": "Fast api is running... ", "Try": "/docs"}

features/text_classifier/controller.py

@@ -0,0 +1,54 @@
+from .inferencer import classify_text
+import asyncio
+from fastapi import HTTPException, UploadFile
+from .preprocess import parse_docx, parse_pdf, parse_txt
+
+from io import BytesIO
+import logging
+
+
+async def handle_text_analysis(text: str):
+    text = text.strip()
+    if not text or len(text.split()) < 2:
+        raise HTTPException(
+            status_code=400, detail="Text must contain at least two words"
+        )
+    label, perplexity = await asyncio.to_thread(classify_text, text)
+    return {"result": label, "perplexity": round(perplexity, 2)}
+
+
+async def handle_file_upload(file: UploadFile):
+    try:
+        file_contents = await extract_file_contents(file)
+        if len(file_contents) > 10000:
+            return {"message": "File contains more than 10,000 characters."}
+        cleaned_text = file_contents.replace("\n", "").replace("\t", "")
+        label, perplexity = await asyncio.to_thread(classify_text, cleaned_text)
+        return {"result": label, "perplexity": round(perplexity, 2)}
+    except Exception as e:
+        logging.error(f"Error processing file: {str(e)}")
+        raise HTTPException(status_code=500, detail="Error processing the file")
+
+
+async def extract_file_contents(file: UploadFile):
+    content = await file.read()
+    file_stream = BytesIO(content)
+
+    if (
+        file.content_type
+        == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    ):
+        return parse_docx(file_stream)
+    elif file.content_type == "application/pdf":
+        return parse_pdf(file_stream)
+    elif file.content_type == "text/plain":
+        return parse_txt(file_stream)
+    else:
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid file type. Only .docx, .pdf, and .txt are allowed.",
+        )
+
+
+def classify(text: str):
+    return classify_text(text)

features/text_classifier/inferencer.py

@@ -0,0 +1,27 @@
+import torch
+from .model_loader import get_model_tokenizer
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def classify_text(text: str):
+    model, tokenizer = get_model_tokenizer()
+    inputs = tokenizer(text, return_tensors="pt",
+                       truncation=True, padding=True)
+    input_ids = inputs["input_ids"].to(device)
+    attention_mask = inputs["attention_mask"].to(device)
+
+    with torch.no_grad():
+        outputs = model(
+            input_ids, attention_mask=attention_mask, labels=input_ids)
+        loss = outputs.loss
+        perplexity = torch.exp(loss).item()
+
+    if perplexity < 60:
+        result = "AI-generated"
+    elif perplexity < 80:
+        result = "Probably AI-generated"
+    else:
+        result = "Human-written"
+
+    return result, perplexity

features/text_classifier/model_loader.py

@@ -0,0 +1,50 @@
+import os
+import shutil
+import logging
+from transformers import GPT2LMHeadModel, GPT2TokenizerFast, GPT2Config
+from huggingface_hub import snapshot_download
+import torch
+from dotenv import load_dotenv
+
+load_dotenv()
+REPO_ID = "Pujan-Dev/AI-Text-Detector"
+MODEL_DIR = "./models"
+TOKENIZER_DIR = os.path.join(MODEL_DIR, "model")
+WEIGHTS_PATH = os.path.join(MODEL_DIR, "model_weights.pth")
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+_model, _tokenizer = None, None
+
+
+def warmup():
+    global _model, _tokenizer
+    download_model_repo()
+    _model, _tokenizer = load_model()
+    logging.info("Its ready")
+
+
+def download_model_repo():
+    if os.path.exists(MODEL_DIR) and os.path.isdir(MODEL_DIR):
+        logging.info("Model already exists, skipping download.")
+        return
+    snapshot_path = snapshot_download(repo_id=REPO_ID)
+    os.makedirs(MODEL_DIR, exist_ok=True)
+    shutil.copytree(snapshot_path, MODEL_DIR, dirs_exist_ok=True)
+
+
+def load_model():
+    tokenizer = GPT2TokenizerFast.from_pretrained(TOKENIZER_DIR)
+    config = GPT2Config.from_pretrained(TOKENIZER_DIR)
+    model = GPT2LMHeadModel(config)
+    model.load_state_dict(torch.load(WEIGHTS_PATH, map_location=device))
+    model.to(device)
+    model.eval()
+    return model, tokenizer
+
+
+def get_model_tokenizer():
+    global _model, _tokenizer
+    if _model is None or _tokenizer is None:
+        download_model_repo()
+        _model, _tokenizer = load_model()
+    return _model, _tokenizer

features/text_classifier/preprocess.py

@@ -0,0 +1,30 @@
+import fitz  # PyMuPDF
+import docx
+from io import BytesIO
+import logging
+from fastapi import HTTPException
+
+
+def parse_docx(file: BytesIO):
+    doc = docx.Document(file)
+    text = ""
+    for para in doc.paragraphs:
+        text += para.text + "\n"
+    return text
+
+
+def parse_pdf(file: BytesIO):
+    try:
+        doc = fitz.open(stream=file, filetype="pdf")
+        text = ""
+        for page_num in range(doc.page_count):
+            page = doc.load_page(page_num)
+            text += page.get_text()
+        return text
+    except Exception as e:
+        logging.error(f"Error while processing PDF: {str(e)}")
+        raise HTTPException(status_code=500, detail="Error processing PDF file")
+
+
+def parse_txt(file: BytesIO):
+    return file.read().decode("utf-8")

features/text_classifier/routes.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from fastapi.security import HTTPBearer
+from pydantic import BaseModel
+from .controller import handle_text_analysis, handle_file_upload
+
+router = APIRouter()
+bearer_scheme = HTTPBearer()
+
+
+class TextInput(BaseModel):
+    text: str
+
+
+@router.post("/analyze")
+async def analyze(data: TextInput, token: str = Depends(bearer_scheme)):
+    return await handle_text_analysis(data.text)
+
+
+@router.post("/upload")
+async def upload_file(
+    file: UploadFile = File(...), token: str = Depends(bearer_scheme)
+):
+    return await handle_file_upload(file)
+
+
+@router.get("/health")
+def health():
+    return {"status": "ok"}

readme.md

@@ -1 +1,316 @@
-# TESTING
+### **FastAPI AI**
+
+This FastAPI app loads a GPT-2 model, tokenizes input text, classifies it, and returns whether the text is AI-generated or human-written.
+
+### **install Dependencies**
+
+```bash
+pip install -r requirements.txt
+
+```
+
+This command installs all the dependencies listed in the `requirements.txt` file. It ensures that your environment has the required packages to run the project smoothly.
+
+**NOTE: IF YOU HAVE DONE ANY CHANGES DON'NT FORGOT TO PUT IT IN THE REQUIREMENTS.TXT USING `bash pip freeze > requirements.txt `**
+
+---
+### Files STructure
+
+```
+├── app.py
+├── features
+│   └── text_classifier
+│       ├── controller.py
+│       ├── inferencer.py
+│       ├── __init__.py
+│       ├── model_loader.py
+│       ├── preprocess.py
+│       └── routes.py
+├── __init__.py
+├── Procfile
+├── readme.md
+└── requirements.txt
+```
+**`app.py`**: Entry point initializing FastAPI app and routes
+**`Procfile`**: Tells Railway how to run the program
+**`requirements.txt`**:Have all the packages that we use in our project 
+**`__init__.py`** : Package initializer for the root module
+**FOLDER :features/text_classifier**
+**`controller.py`** :Handles logic between routes and model
+**`inferencer.py`** : Runs inference and returns predictions as well as files system
+**`__init__.py`** :Initializes the module as a package
+**`model_loader.py`** : Loads the ML model and tokenizer
+**`preprocess.py`** :Prepares input text for the model 
+**`routes.py`** :Defines API routes for text classification
+
+### **Functions**
+
+1. **`load_model()`**  
+   Loads the GPT-2 model and tokenizer from specified paths.
+
+2. **`lifespan()`**  
+   Manages the app's lifecycle: loads the model at startup and handles cleanup on shutdown.
+
+3. **`classify_text_sync()`**  
+   Synchronously tokenizes input text and classifies it using the GPT-2 model. Returns the classification and perplexity.
+
+4. **`classify_text()`**  
+   Asynchronously executes `classify_text_sync()` in a thread pool to ensure non-blocking processing.
+
+5. **`analyze_text()`**  
+   **POST** endpoint: accepts text input, classifies it using `classify_text()`, and returns the result with perplexity.
+
+6. **`health()`**  
+   **GET** endpoint: simple health check to confirm the API is running.
+7. **`parse_docx() ,parse_pdf(),parse_txt()`**
+  THis are the function that are used to convert the given docs, pdf or text files into the strings format so that we can classify them.
+8. **`warmup()`**
+    This  function is used to downlaod the repo and init the _model and _tokenizer from load_model() function
+9. **`download_model_repo()`**
+    This function is use to download the model from the MODEL folder
+10. **`get_model_tokenizer()`** 
+This function is similler to the warmup but it also check if the model is already exist or not if not exist then download it else let it be or use previous downloaded model
+
+11. **`handle_file_upload()`**
+This function is use to handle the file upload in the upload route and classify and returns the results.
+12. **`Extract_file_contents()`**
+This function is use to extract the contains from the files and return the text from the files.
+
+---
+
+### **Code Overview**
+
+### **Running and Load Balancing:**
+
+To run the app in production with load balancing:
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 8000 
+```
+
+This command launches the FastAPI app.
+
+
+### **Endpoints**
+
+#### 1. **`/text/analyze`**
+
+- **Method:** `POST`
+- **Description:** Classifies whether the text is AI-generated or human-written.
+- **Request:**
+  ```json
+  { "text": "sample text" }
+  ```
+- **Response:**
+  ```json
+  { "result": "AI-generated", "perplexity": 55.67 }
+  ```
+
+#### 2. **`/health`**
+
+- **Method:** `GET`
+- **Description:** Returns the status of the API.
+- **Response:**
+  ```json
+  { "status": "ok" }
+  ```
+#### 3. **`/text/upload`**
+- **Method:** `POST`
+- **Description:** Takes the files and check the contains inside and returns the results
+- **Request:** Files
+
+- **Response:**
+```json
+ { "result": "AI-generated", "perplexity": 55.67 }
+```
+---
+
+### **Running the API**
+
+Start the server with:
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+---
+
+### **🧪 Testing the API**
+
+You can test the FastAPI endpoint using `curl` like this:
+
+```bash
+curl -X POST https://can-org-canspace.hf.space/analyze \
+  -H "Authorization: Bearer SECRET_CODE" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "This is a sample sentence for analysis."}'
+```
+
+- The `-H "Authorization: Bearer SECRET_CODE"` part is used to simulate the **handshake**.
+- FastAPI checks this token against the one loaded from the `.env` file.
+- If the token matches, the request is accepted and processed.
+- Otherwise, it responds with a `403 Unauthorized` error.
+
+---
+
+### **API Documentation**
+
+- **Swagger UI:** `https://can-org-canspace.hf.space/docs` -> `/docs`
+- **ReDoc:** `https://can-org-canspace.hf.space/redoc` -> `/redoc`
+
+### **🔐 Handshake Mechanism**
+
+In this part, we're implementing a simple handshake to verify that the request is coming from a trusted source (e.g., our NestJS server). Here's how it works:
+
+- We load a secret token from the `.env` file.
+- When a request is made to the FastAPI server, we extract the `Authorization` header and compare it with our expected secret token.
+- If the token does **not** match, we immediately return a **403 Forbidden** response with the message `"Unauthorized"`.
+- If the token **does** match, we allow the request to proceed to the next step.
+
+The verification function looks like this:
+
+```python
+def verify_token(auth: str):
+    if auth != f"Bearer {EXPECTED_TOKEN}":
+        raise HTTPException(status_code=403, detail="Unauthorized")
+```
+
+This provides a basic but effective layer of security to prevent unauthorized access to the API.
+
+### **Implement it with NEST.js**
+
+NOTE: Make an micro service in NEST.JS and implement it there and call it from app.controller.ts
+
+in fastapi.service.ts file what we have done is
+
+### Project Structure
+
+```files
+nestjs-fastapi-bridge/
+├── src/
+│   ├── app.controller.ts
+│   ├── app.module.ts
+│   └── fastapi.service.ts
+├── .env
+
+```
+
+---
+
+### Step-by-Step Setup
+
+#### 1. `.env`
+
+Create a `.env` file at the root with the following:
+
+```environment
+  FASTAPI_BASE_URL=https://can-org-canspace.hf.space/
+  SECRET_TOKEN="SECRET_CODE_TOKEN"
+```
+
+#### 2. `fastapi.service.ts`
+
+```javascript
+  // src/fastapi.service.ts
+  import { Injectable } from "@nestjs/common";
+  import { HttpService } from "@nestjs/axios";
+  import { ConfigService } from "@nestjs/config";
+  import { firstValueFrom } from "rxjs";
+
+  @Injectable()
+  export class FastAPIService {
+    constructor(
+      private http: HttpService,
+      private config: ConfigService,
+    ) {}
+
+    async analyzeText(text: string) {
+      const url = `${this.config.get("FASTAPI_BASE_URL")}/analyze`;
+      const token = this.config.get("SECRET_TOKEN");
+
+      const response = await firstValueFrom(
+        this.http.post(
+          url,
+          { text },
+          {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          },
+        ),
+      );
+
+      return response.data;
+    }
+  }
+```
+
+#### 3. `app.module.ts`
+
+```javascript
+// src/app.module.ts
+import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+import { HttpModule } from "@nestjs/axios";
+import { AppController } from "./app.controller";
+import { FastAPIService } from "./fastapi.service";
+
+@Module({
+  imports: [ConfigModule.forRoot(), HttpModule],
+  controllers: [AppController],
+  providers: [FastAPIService],
+})
+export class AppModule {}
+```
+
+---
+
+#### 4. `app.controller.ts`
+
+```javascript
+  // src/app.controller.ts
+  import { Body, Controller, Post, Get, Query } from '@nestjs/common';
+  import { FastAPIService } from './fastapi.service';
+
+  @Controller()
+  export class AppController {
+    constructor(private readonly fastapiService: FastAPIService) {}
+
+    @Post('analyze-text')
+    async callFastAPI(@Body('text') text: string) {
+      return this.fastapiService.analyzeText(text);
+    }
+
+    @Get()
+    getHello(): string {
+      return 'NestJS is connected to FastAPI ';
+    }
+  }
+```
+
+### 🚀 How to Run
+
+Run the server of flask and nest.js:
+
+- for nest.js
+  ```bash
+  npm run start
+  ```
+- for Fastapi
+
+  ```bash
+  uvicorn app:app --reload
+  ```
+
+Make sure your FastAPI service is running at `http://localhost:8000`.
+
+### Test with CURL
+http://localhost:3000/-> Server of nest.js
+```bash
+curl -X POST http://localhost:3000/analyze-text \
+  -H 'Content-Type: application/json' \
+  -d '{"text": "This is a test input"}'
+```
+
+
+

requirements.txt

@@ -1,7 +1,11 @@
-torch==2.6.0
-transformers==4.51.3
-fastapi==0.103.0
-pydantic==1.10.12
-asyncio==3.4.3
-uvicorn[standard]==0.21.1
-
+fastapi
+uvicorn
+torch
+transformers
+huggingface_hub
+python-dotenv
+python-docx
+PyMuPDF
+pydantic
+fitz
+python-multipart