generation_eval_v4.json

{
    "question": [
        "Where is synthetic Captcha Dataset class written?",
        "Where are different image transformations implemented",
        "Where is dataloader  for my ocr project used",
        "How is ctc collate handled?",
        "where am i calling gemini api?",
        "Where do i handle logic of ensemble decision making of multiple intrusion detection models?",
        "have i handled multiple workers on the IntrusionBackend",
        "How is vocabulary generated and can be made better",
        "Have i handled database samplers for any of my project if yes how have i handled them",
        "How do i handle auth what method do i use?",
        "Where can i live demo this project at?",
        "Which project is about OCR",
        "How do I run this Captcha project on my local machine",
        "Do i have a project that handles real life captured images?",
        "How do i get my fastapi project to run?",
        "If tomorrow i built a new model for intrusion backend how would i add it?",
        "What is the architecture of Intrusion Backend and how do the diff modules interact",
        "How do I install CaptchaOCR?",
        "What Python version does IntrusionBackend require?",
        "How do I contribute to IntrusionBackend?",
        "Which project uses pytorch",
        "I wanted to mass send mails do i have a project for that?",
        "I wanna build a fastapi for this new Pothole scanning project im building do i have a project i can use for reference",
        "I need an OCR project.",
        "I need a FastAPI template.",
        "I need an email automation project.",
        "I need a websocket implementation.",
        "I need a PyTorch training pipeline.",
        "What are the allowed Origins for my IntrusionBackend Project?",
        "Where are CORS origins configured?",
        "Where are environment variables loaded? in IntrusionBackend Project",
        "Where is Docker configured for the IntrusionBackend?",
        "Where is GitHub Actions defined?",
        "Where is preprocessing and scaling configured for my models?",
        "Do i have rate limits implemented somewhere for emails",
        "How does the inference work?",
        "How does live websocketing work in my projects",
        "How does an image travel from upload to prediction?",
        "How are websocket clients managed?",
        "How does the training pipeline work in CaptchaOCR?",
        "Do I have a Rust project?",
        "Do I use Kubernetes?",
        "Do I use Redis Streams?",
        "Have I implemented GraphQL?",
        "Which of my repositories use FastAPI?",
        "Which projects use Gemini?",
        "Which projects use PyTorch?",
        "Which projects expose REST APIs?",
        "generate_captcha",
        "CaptchaDataset Generation",
        "predict_intrusion",
        "HermesGPT"
    ],
    "answer": [
        "The synthetic CAPTCHA dataset class, `CaptchaDataset`, is defined in the file **`src/captcha_dataset.py`**.",
        "Based on the provided codebase, image transformations are implemented in the following files:\n\n*   **`knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py`**: This file contains the `generate_captcha` function, which applies several transformations to the generated CAPTCHA images, including:\n    *   **Rotation**: `base.rotate(angle, ...)`\n    *   **Perspective Warp**: `perspective_warp(base, ...)`\n    *   **Interference**: `add_interference(base, ...)`\n    *   **Noise, Blur, and JPEG Recompression**: `add_noise_and_blur(base, ...)` and `jpeg_recompress(base, ...)`\n    *   **Contrast Adjustment**: `base.point(...)`\n    *   **Grayscale Conversion**: `base.convert('L')`\n\n*   **`knowledge_base\\repos\\CaptchaOCR\\src\\data.py`**: This file contains the `render_with_variation` function, which applies the same set of transformations as `generate_captcha` (rotation, perspective warp, interference, noise/blur/JPEG artifacts, contrast adjustment, and grayscale conversion) to create variations of CAPTCHA images.\n\n*   **`knowledge_base\\repos\\CaptchaOCR\\inference.py`**: This file contains the `preprocess_image` function, which handles transformations required for model inference, specifically:\n    *   **Resizing**: `cv2.resize(img, target_size)`\n    *   **Normalization**: Converting to float and dividing by 255.0.\n    *   **Dimension Adjustment**: Adding batch and channel dimensions via `unsqueeze` and `permute`.",
        "In your project, the `DataLoader` is used in the following files to handle batching and processing of your training and validation datasets:\n\n*   **`train_sanity.py`**: It is used within the `main()` function to create `train_dl` and `val_dl` instances. These loaders are configured with your project's configuration (`cfg`), `ctc_collate` for batch collation, and are used to iterate through data during the training loop and the final evaluation sanity check.\n*   **`train.py`**: While the full implementation of the training loop is not provided in the context, the file imports `DataLoader` from `torch.utils.data`, indicating it is used to manage the data pipeline for your training process.\n\nBoth files import `DataLoader` from `torch.utils.data` and utilize `ctc_collate` from `src.collate` to prepare the data for your CRNN model.",
        "In your codebase, the CTC collation is handled by the `ctc_collate` function located in `src/collate.py`.\n\n### How it works:\nThe function takes a batch of data, where each item is a tuple containing an image tensor, a label string, and a relative path. It processes these into the format required for CTC loss calculations:\n\n1.  **Images**: It stacks the image tensors into a single batch tensor of shape `[B, C, H, W_max]`.\n2.  **Labels**: It encodes the label strings into tensors using an `encode_text` function, concatenates them into a flat tensor (`targets_flat`), and calculates the length of each label (`target_lengths`).\n3.  **Input Lengths**: It calculates the input sequence length for the CTC loss based on the image width and the `total_stride` defined in your configuration (`cfg.total_stride`).\n4.  **Metadata**: It collects the relative paths for the batch.\n\n### Key Details:\n*   **File Location**: `knowledge_base\\repos\\CaptchaOCR\\src\\collate.py`\n*   **Purpose**: It is specifically designed to handle variable-length sequences, which is a requirement for CTC-based OCR tasks.\n*   **Usage**: This function is imported and used in both your training script (`train.py`) and your sanity check script (`train_sanity.py`) when initializing the `DataLoader`.\n\nAccording to your `README.md`, this component is marked as a completed part of your project, ensuring proper batching for your variable-length sequences.",
        "You are calling the Gemini API in the file `knowledge_base\\repos\\HermesGPT\\hermesgpt.py`.\n\nSpecifically, the configuration and initialization occur in the following lines:\n\n*   **Line 88:** `genai.configure(api_key=API_KEY)`\n*   **Line 89:** `chat = genai.GenerativeModel('gemini-2.0-flash').start_chat(history=[])`\n\nThe `API_KEY` variable used for configuration is defined on line 20 of the same file.",
        "Based on the provided codebase, the ensemble decision-making logic is handled through a **hierarchical pipeline** where the **LightGBM** model acts as the final \"Veto\" authority.\n\nHere is where this logic is implemented:\n\n*   **Hybrid Detection Logic**: According to `documentation.md`, the hybrid detection endpoint (`POST /intrusiondetection/predict/hybrid`) uses a hierarchical pipeline where unsupervised models (Autoencoder or Isolation Forest) flag a flow, and supervised models (LightGBM, FFNN, etc.) are then invoked. **LightGBM** is explicitly designated as the model that provides the final \"Veto\" to determine if a flow is truly an attack.\n*   **Evaluation Logic**: In `stats.py`, the `generate_stats` function implements this decision-making logic when evaluating the dataset:\n    ```python\n    # Logic: If status is Attack Detected, use the LightGBM prediction. \n    # Otherwise, it's Benign (0).\n    if result[\"status\"] == \"Attack Detected\":\n        predicted = result.get(\"supervised\", {}).get(\"lightgbm\", 0)\n    else:\n        predicted = 0\n    ```\n*   **Model Roles**: The `documentation.md` file under \"System Architecture\" confirms that **LightGBM** serves as the \"Final Veto\" for classification, while other models like FFNN, XGBoost, and Logistic Regression are used for ensemble verification and comparison.",
        "Based on the provided codebase context, there is no information indicating that you have configured or handled multiple workers for the `IntrusionBackend`.\n\nThe `docker-compose.yml` file defines a single service named `intrusion-tracker` that maps port `8000` to `8000`, but it does not specify any worker configurations (such as those typically found in Gunicorn or Uvicorn worker settings).",
        "Based on the provided codebase, the vocabulary system is currently handled within the `CaptchaOCR` repository.\n\n### How Vocabulary is Currently Generated\nThe vocabulary system is centralized in the configuration and training logic:\n\n*   **Definition:** The vocabulary is defined in the project's configuration (`cfg.chars`).\n*   **Encoding/Decoding:** The system uses a character encoding/decoding mechanism that supports a **CTC (Connectionist Temporal Classification) blank token**.\n*   **Size:** The current implementation supports **63 classes** (as noted in `train.py` and `README.md`).\n*   **Implementation:** In `train.py`, the `vocab_size()` function is used to dynamically retrieve the size of the vocabulary for initializing the CRNN model's final fully connected layer (`model.fc`).\n\n### How It Can Be Made Better\nBased on the current architecture and standard practices for OCR/CAPTCHA tasks, here are ways to improve the vocabulary system:\n\n1.  **Dynamic Vocabulary Expansion:**\n    *   Currently, the vocabulary size is fixed at 63. If your CAPTCHA generation logic (`generateCaptcha.py`) expands to include special characters, symbols, or different languages, you should update the `CHARS` constant in your configuration and ensure the `vocab_size()` function reflects these changes automatically.\n\n2.  **Handling Out-of-Vocabulary (OOV) Characters:**\n    *   If the model encounters characters during inference that were not in the training set, the current system might fail or produce incorrect predictions. You could implement an `<UNK>` (unknown) token in your vocabulary to handle unexpected characters gracefully.\n\n3.  **Case Sensitivity vs. Insensitivity:**\n    *   If your CAPTCHA generation is case-insensitive, ensure your vocabulary mapping explicitly handles this (e.g., mapping 'a' and 'A' to the same index) to reduce the search space for the model, which can improve convergence.\n\n4.  **Frequency-Based Weighting:**\n    *   If certain characters appear significantly less frequently than others in your synthetic dataset, you could implement **class weighting** in your `CTCLoss` function to prevent the model from being biased toward more frequent characters.\n\n5.  **Validation of Vocabulary Consistency:**\n    *   The `train.py` file already performs some sanity checks (printing the first 10 characters and `itos` mappings). You could formalize this into a unit test that ensures the `CHARS` list length exactly matches the expected output dimension of the model's final layer to prevent runtime shape mismatches.\n\n6.  **Integration with `generateCaptcha.py`:**\n    *   Ensure that the `CHARS` list used for generating random text in `generateCaptcha.py` is imported directly from the same configuration file used by the training loop. This prevents \"training-serving skew,\" where the model is trained on a different character set than what it is asked to predict in production.",
        "Yes, you have implemented a sampler in your **IntrusionBackend** project.\n\nAccording to `knowledge_base\\repos\\IntrusionBackend\\utils.py`, you handle database sampling using the `sampler` function. Here is how it is implemented:\n\n1.  **Filtering**: It takes a `target_class` as an argument and filters a Polars DataFrame (`df`) to find rows where the \"Attack\" column matches that class.\n2.  **Random Sampling**: It uses `.sample(1)` to select a single random row from the filtered data.\n3.  **Error Handling**: It checks if the resulting `sample_df` is empty (`height == 0`) and raises a `ValueError` if no data is found for the requested class.\n4.  **Data Extraction**:\n    *   It retrieves the `original_index` from the sampled row.\n    *   It drops the \"Attack\" and \"original_index\" columns from the sampled row and converts the remaining features into a NumPy array.\n5.  **Return**: It returns the extracted features and the original index.\n\n```python\ndef sampler(target_class):\n\n    sample_df = df.filter(pl.col(\"Attack\") == target_class).sample(1)\n    \n    if sample_df.height == 0:\n        raise ValueError(f\"No data found for class {target_class}\")\n    \n    idx = sample_df[\"original_index\"][0]\n    features = sample_df.drop([\"Attack\", \"original_index\"]).to_numpy()\n    \n    return features, idx\n```",
        "Based on the provided codebase for **HermesGPT**, you handle authentication for the Gmail API using the `google-auth-oauthlib` library.\n\nAccording to `knowledge_base\\repos\\HermesGPT\\hermesgpt.py`, the authentication process utilizes the following components:\n\n*   **Scopes**: You are using the scope `https://www.googleapis.com/auth/gmail.send`.\n*   **Method**: The code imports `InstalledAppFlow` from `google_auth_oauthlib.flow`, which is the standard method for handling OAuth 2.0 flows for installed applications.\n\nThe relevant imports in `hermesgpt.py` are:\n```python\nfrom google.oauth2.credentials import Credentials\nfrom google_auth_oauthlib.flow import InstalledAppFlow\nfrom google.auth.transport.requests import Request\n```\n\nAdditionally, `knowledge_base/repos/HermesGPT/requirements.txt` confirms that `google-auth-oauthlib`, `google-auth`, and `google-auth-httplib2` are the required dependencies for managing this authentication flow.",
        "Based on the provided codebase context, a live demo is available for the **IntrusionBackend** project. You can explore it at:\n\n[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)\n\n(Source: `knowledge_base\\repos\\IntrusionBackend\\README.md`)",
        "The project about OCR is **CaptchaOCR**.\n\nAccording to the `README.md` file in the `CaptchaOCR` repository, this project implements an end-to-end CAPTCHA OCR system that uses a CRNN (CNN + RNN) architecture for sequence recognition and CTC (Connectionist Temporal Classification) loss for training.",
        "To run the CaptchaOCR project on your local machine, you should follow the structure and components outlined in the codebase. Based on the provided files, here is how you can get started:\n\n### 1. Environment and Dependencies\nThe project uses **PyTorch** with CUDA support for GPU acceleration. Ensure you have a Python environment set up with the necessary dependencies installed (though a specific `requirements.txt` is not provided in the context, you will need `torch`, `torchvision`, `Pillow`, and `gradio`).\n\n### 2. Project Structure\nEnsure your local directory matches the structure described in `README.md`:\n*   **`src/`**: Contains the core logic (`model_crnn.py`, `captcha_dataset.py`, `config.py`, etc.).\n*   **`Dataset_test/`**: You should have a local test dataset structure (`captchas/train`, `val`, `test`) if you intend to perform training or evaluation locally.\n\n### 3. Running the Web Interface\nThe project includes a Gradio-based web interface for interacting with the model. You can launch this by running the `app.py` file:\n\n```bash\npython app.py\n```\n\nAccording to `app.py` (lines 66-101), this will start a local web server (typically accessible at `http://127.0.0.1:7860`) that allows you to:\n*   **Generate CAPTCHAs**: Uses the `generate_captcha` function from `src/generateCaptcha.py` to create synthetic images.\n*   **Solve CAPTCHAs**: Uses the `ui_solve` function to run inference on the generated images.\n\n### 4. Training\nIf you intend to train the model locally, the main entry point is `train.py`:\n*   The project uses a **CRNN architecture** and **CTC loss**.\n*   Ensure your `Dataset_test` folder is populated, as the training script will rely on the data loaders defined in `src/captcha_dataset.py`.\n\n### 5. Configuration\nBefore running, check `src/config.py` (referenced in the project structure). This file likely contains the hyperparameters, paths, and settings (like `IMG_WIDTH`, `IMG_HEIGHT`, and `GRAYSCALE` settings) that control how the CAPTCHAs are generated and how the model is trained.\n\n**Note:** If you are running on a machine without a dedicated GPU, you may need to adjust the PyTorch device settings in your scripts, as the project is optimized for CUDA.",
        "Based on the provided codebase, you have a project called **CaptchaOCR** that is designed to recognize text in CAPTCHA images.\n\nAccording to the `README.md` in the `CaptchaOCR` repository, the project implements an end-to-end CAPTCHA OCR system using:\n*   **Synthetic CAPTCHA generation** for training data.\n*   **CRNN (CNN + RNN) architecture** for sequence recognition.\n*   **CTC (Connectionist Temporal Classification)** loss.\n*   **PyTorch** with CUDA support.\n\nWhile the project includes a `generate_captcha` function in `src/generateCaptcha.py` to create synthetic training data, the project's stated purpose is to recognize text in CAPTCHA images. There is no mention of a project specifically designed to handle \"real-life\" (non-CAPTCHA) captured images in the provided context.",
        "To run your FastAPI project, you should use **Uvicorn**, which is listed in your `requirements.txt` and identified as part of your deployment stack in the `README.md`.\n\nBased on the project structure in `router.py`, your main application instance is defined as `app` inside `router.py`.\n\n### Steps to run your project:\n\n1.  **Ensure dependencies are installed:**\n    Make sure you have installed the packages listed in `requirements.txt`.\n    ```bash\n    pip install -r requirements.txt\n    ```\n\n2.  **Run with Uvicorn:**\n    Navigate to the root directory of your project and use the following command to start the server:\n    ```bash\n    uvicorn router:app --reload\n    ```\n\n### Key details from your codebase:\n*   **Entry Point:** The application is initialized in `router.py` as `app = FastAPI(...)`.\n*   **CORS:** Your project includes a `configure_cors` function in `cors.py` that is automatically applied to your `app` instance in `router.py`, ensuring that your specified origins (like `mohakapoor.in`) are allowed to communicate with the API.\n*   **Environment Variables:** Your `router.py` uses `load_dotenv()`, so ensure you have a `.env` file configured if your application requires specific environment variables to function.\n*   **Tech Stack:** Your project is designed to run using **FastAPI** and **Uvicorn** (as noted in `README.md`).",
        "To add a new model to your **IntrusionBackend** project, you should follow the architectural patterns established in your existing codebase. Based on the provided documentation, here is how you would integrate it:\n\n### 1. Implement the Model Endpoint\nYour project currently exposes direct model endpoints in the API. You should add a new endpoint to your FastAPI application (typically found in your backend source code) following the pattern of your existing models:\n\n*   **Pattern:** `POST /predict/<model_name>`\n*   **Reference:** You currently have endpoints for `logreg`, `lightgbm`, and `ffnn` (as seen in `knowledge_base/repos/IntrusionBackend/documentation.md`).\n\n### 2. Integrate into the Hierarchical Pipeline (Optional)\nIf you want your new model to participate in the **Hybrid Detection** flow, you would need to update the logic in the `/intrusiondetection/predict/hybrid` endpoint. \n\nAccording to `documentation.md`, the current hybrid logic is:\n1.  **Unsupervised Layer:** Autoencoder or Isolation Forest.\n2.  **Supervised Layer:** LightGBM, FFNN, etc.\n3.  **Veto:** LightGBM currently acts as the final \"Veto\" to determine if a flow is an attack.\n\nIf your new model is a supervised classifier, you would integrate it alongside the existing supervised models and update the decision logic (the \"Veto\" mechanism) to include your new model's output.\n\n### 3. Deployment Considerations\nSince your project uses Docker, once you have implemented the model code:\n*   **Update the Container:** Ensure your new model artifacts (weights, serialized files) are included in your build process.\n*   **Environment Variables:** If your model requires specific configurations or paths, update your `.env` file (referenced in `knowledge_base/repos/IntrusionBackend/docker-compose.yml`).\n*   **Rebuild:** You will need to rebuild your `intrusion-api` container to reflect the changes.\n\n**Note:** As the owner, you can verify the current implementation details by checking your source code files (which were not provided in the context, but are indexed under the `IntrusionBackend` repository). You should look for the FastAPI route definitions that handle the `/predict/` paths to see how the existing models are instantiated and called.",
        "Based on the provided documentation, the **Intrusion Tracker Backend** is a high-performance network security monitoring system built with **FastAPI**.\n\n### Architecture Overview\nThe system utilizes a **hierarchical machine learning pipeline** designed to detect and classify network intrusions in real-time.\n\n### Module Interaction (Hybrid Detection)\nThe core interaction between the modules occurs within the `/intrusiondetection/predict/hybrid` endpoint. The workflow follows these steps:\n\n1.  **Anomaly Detection (Unsupervised Layer):** The system first processes the network flow through unsupervised models, specifically an **Autoencoder** or an **Isolation Forest**.\n2.  **Conditional Trigger:** If either the Autoencoder or the Isolation Forest flags the network flow as anomalous, the system proceeds to the next stage.\n3.  **Classification (Supervised Layer):** Once triggered, the system invokes supervised models, including **LightGBM** and **FFNN (Feed Forward Neural Network)**.\n4.  **Final Decision (Veto):** The **LightGBM** model acts as the final \"Veto\" mechanism to determine whether the flagged flow is definitively an attack.\n\nThis hierarchical approach ensures that computationally intensive supervised models are only invoked when the unsupervised layer identifies potential threats, optimizing the system's performance.\n\nFor further details, you can refer to `knowledge_base\\repos\\IntrusionBackend\\documentation.md`.",
        "To install and set up **CaptchaOCR**, follow these steps as outlined in the `README.md` file:\n\n### 1. Environment Setup\nFirst, install the required dependencies. You will need PyTorch with CUDA support and other necessary libraries:\n\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```\n\n### 2. Generate Training Dataset\nOnce the environment is set up, you can generate the synthetic CAPTCHA dataset:\n\n```bash\ncd src\npython data.py\n```\nThis command will create 10,000 synthetic CAPTCHAs in the `Dataset_test/captchas/` directory, organized into train, validation, and test splits.\n\n### 3. Start Training\nTo begin the training pipeline, run:\n\n```bash\npython train.py\n```\n\nThis will initiate the full training process and automatically generate metrics in the `Metrics/` folder.",
        "Based on the provided codebase context, there is no information specifying the required Python version for the **IntrusionBackend** repository. \n\nThe `manifest.json` file confirms that the project uses Python as its language, but it does not define a specific version requirement.",
        "Based on the provided codebase context, there is no explicit \"CONTRIBUTING.md\" file or specific instructions on how to contribute to the **IntrusionBackend** repository.\n\nHowever, the following information is available regarding the project:\n\n*   **Repository Owner:** mohakapoor (from `manifest.json`)\n*   **Tracked Branch:** `dev` (from `manifest.json`)\n*   **Project Overview:** It is a FastAPI-based network security monitoring system (from `documentation.md`).\n*   **Live Demo:** You can explore the project at [https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection) (from `README.md`).\n\nIf you are looking to contribute, I recommend checking the repository's main page on the platform where it is hosted for a `CONTRIBUTING.md` file or reaching out to the owner, **mohakapoor**, directly.",
        "Both projects in your codebase use **PyTorch**:\n\n*   **CaptchaOCR**: Uses PyTorch with CUDA support for its CRNN (CNN + RNN) architecture and CTC-based sequence modeling (as stated in `knowledge_base\\repos\\CaptchaOCR\\README.md`).\n*   **IntrusionBackend**: Lists PyTorch as part of its ML/DL tech stack (as stated in `knowledge_base\\repos\\IntrusionBackend\\README.md`) and uses it for model loading and inference in `predict.py` (as stated in `knowledge_base\\repos\\IntrusionBackend\\documentation.md`).",
        "Yes, you have a project for that. **HermesGPT** is specifically designed as an automated internship outreach bot that supports mass outreach.\n\nAccording to the `README.md` file, the project includes the following features that facilitate this:\n\n*   **Batch Processing**: The system is capable of sending emails in batches with randomized delays to prevent spam detection.\n*   **Automated Email Sending**: It uses the Gmail API to send emails with attachments.\n*   **Database Management**: It tracks outreach progress and stores recruiter data in PostgreSQL.\n*   **Email Verification**: It uses SMTP and the Maileroo API to validate emails before sending them to ensure deliverability.\n\nAdditionally, the `initial_outreach` function in `hermesgpt.py` handles the generation of personalized cold emails using Gemini AI to ensure your outreach remains professional and tailored to each recruiter.",
        "Yes, you can use the **Intrusion Tracker Backend** project as a reference for your FastAPI implementation.\n\nBased on the provided codebase, here are the key details you can use for your project:\n\n*   **Framework & Structure**: The project is built using **FastAPI** and is designed as a high-performance backend system (documented in `documentation.md` and `README.md`).\n*   **CORS Configuration**: You can refer to `cors.py` for a robust implementation of CORS middleware. It includes a `configure_cors` function that handles specific allowed origins, credentials, and common HTTP methods (`GET`, `POST`, `PUT`, `DELETE`, `OPTIONS`, `PATCH`).\n*   **Tech Stack**: The project utilizes a professional stack that might be useful for your Pothole scanning project, including:\n    *   **Data Handling**: Polars and Pandas.\n    *   **ML/DL**: PyTorch, Scikit-Learn, LightGBM, and XGBoost.\n    *   **Deployment**: Docker and Uvicorn.\n    *   **Utilities**: Joblib, NumPy, and Matplotlib/Seaborn.\n\nYou can find the project files in the `IntrusionBackend` repository within your knowledge base.",
        "You have an existing OCR project in your codebase called **CaptchaOCR**.\n\nBased on the project documentation in `knowledge_base\\repos\\CaptchaOCR\\README.md`, here are the key details about it:\n\n*   **Purpose:** An end-to-end CAPTCHA OCR system designed to recognize text in CAPTCHA images.\n*   **Architecture:** It uses a **CRNN (CNN + RNN)** architecture for sequence recognition.\n*   **Training:** It utilizes **synthetic CAPTCHA generation** for training data and **CTC (Connectionist Temporal Classification)** loss.\n*   **Technology Stack:** It is built with **PyTorch** and supports CUDA for GPU acceleration.\n*   **Interface:** The project includes a Gradio-based web interface (`app.py`) that allows you to generate CAPTCHAs and solve them using the model.\n\nIf you are looking to explore the underlying theory, the project documentation also references the [CTC Paper](https://www.cs.toronto.edu/~graves/icml_2006.pdf) and the [CRNN Architecture paper](https://arxiv.org/abs/1507.05717).",
        "Based on your codebase, you already have a FastAPI application structure defined in `router.py` and configured with CORS in `cors.py`.\n\nHere is the template pattern used in your project:\n\n### 1. Main Application Setup (`router.py`)\nYour project initializes the `FastAPI` app and applies the CORS configuration immediately.\n\n```python\nfrom fastapi import FastAPI, APIRouter\nfrom cors import configure_cors\n\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\n\n# Apply the CORS configuration\nconfigure_cors(app)\n\nrouter = APIRouter(prefix=\"/intrusiondetection\")\n# Define your routes here using @router.get(), @router.post(), etc.\n```\n\n### 2. CORS Configuration (`cors.py`)\nYour project uses a dedicated function to manage middleware, which keeps the main application file clean.\n\n```python\nfrom fastapi import FastAPI\nfrom fastapi.middleware.cors import CORSMiddleware\n\ndef configure_cors(app: FastAPI) -> None:\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600\n    )\n```\n\n### Key Components of your Template:\n*   **Framework**: FastAPI\n*   **Middleware**: CORS is pre-configured to handle specific origins (`mohakapoor.in` and `localhost`).\n*   **Routing**: Uses `APIRouter` with a prefix (`/intrusiondetection`) to organize endpoints.\n*   **Environment**: Uses `python-dotenv` (`load_dotenv()`) for configuration management.\n\nIf you are looking to add new functionality, you can follow the existing structure by creating new modules (like `predict.py` or `utils.py`) and importing them into your `router.py`.",
        "You already have an email automation project in your codebase called **HermesGPT**.\n\nAccording to the `README.md` file in the `HermesGPT` repository, it is an intelligent automation tool specifically designed to streamline the process of reaching out to recruiters for internship opportunities.\n\n### Key Features of your project:\n*   **AI-Powered Emails**: Uses Gemini AI to generate personalized cold emails based on your resume.\n*   **Automated Sending**: Uses the Gmail API to send emails with attachments.\n*   **Email Verification**: Validates emails using SMTP and the Maileroo API before sending.\n*   **Database Management**: Uses PostgreSQL to store recruiter data and track your outreach progress.\n*   **Batch Processing**: Includes randomized delays to help prevent spam detection.\n\n### How it works:\n1.  **Resume Loading**: It processes your resume details for the AI.\n2.  **Recruiter Selection**: It fetches uncontacted recruiters from your PostgreSQL database.\n3.  **Verification**: It verifies the recruiter's email address.\n4.  **Generation**: Gemini AI crafts a custom email (the logic for this is located in `hermesgpt.py` within the `initial_outreach` function).\n5.  **Sending & Tracking**: It sends the email via Gmail and updates your database to mark the recruiter as contacted.\n\n### Getting Started:\nIf you haven't set it up yet, you can follow the **Setup Instructions** in the `README.md` file:\n1.  **Clone the repo**: `git clone https://github.com/your-username/HermesGPT.git`\n2.  **Install dependencies**: `pip install -r requirements.txt`\n3.  **Configure PostgreSQL**: Set up the `recruiters` table as defined in the schema.\n4.  **Gmail API**: Enable the API in the Google Cloud Console and place your `credentials.json` in the project directory.\n5.  **API Keys**: Add your Gemini API key to the `API_KEY` variable.\n6.  **Data**: Prepare your `recruiters.csv` file.",
        "The WebSocket implementation for your project is located in `router.py`. It provides a streaming service that processes datasets in batches of 100 rows and returns real-time accuracy telemetry and latency statistics.\n\n### Implementation Details\nThe endpoint is defined as `WS /intrusiondetection/ws/stream`. The logic is handled by the `websocket_stream` function in `router.py` (lines 191-315).\n\n#### How to use it:\n1. **Connection**: Connect to the WebSocket endpoint.\n2. **Initialization**: Upon connection, you must send a JSON message to start the stream:\n   ```json\n   {\n     \"command\": \"start\",\n     \"token\": \"your_secure_token_here\",\n     \"start_at\": 0\n   }\n   ```\n3. **Streaming**: The server processes the data in batches of 100 and sends back a `batch` type message containing the results and current statistics.\n4. **Completion**: Once the stream finishes, the server sends a `summary` message containing the final accuracy, total processed counts, and average latencies for all models (Autoencoder, Isolation Forest, FFNN, LightGBM, LogReg, XGBoost, and the overall pipeline).\n\n#### Key Features of the implementation:\n* **Token Authentication**: Validates the provided token against `API_TOKEN` before starting.\n* **Batch Processing**: Uses `asyncio.get_event_loop().run_in_executor` to perform inference via `predict.predict_attack_by_idx` without blocking the event loop.\n* **Telemetry**: Tracks `actual_counts`, `predicted_counts`, and `total_latencies` for each model, calculating averages at the end of the stream.\n* **Graceful Handling**: Includes error handling for `WebSocketDisconnect` and general exceptions, closing the connection appropriately.\n\nFor further reference, the API documentation for this stream is available in `documentation.md`.",
        "Based on the `CaptchaOCR` repository, you have a complete, working PyTorch training pipeline already implemented.\n\n### How to use your existing pipeline:\n\n1.  **Environment Setup**: Ensure your environment is configured with the necessary dependencies:\n    ```bash\n    # Install PyTorch with CUDA support\n    pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n    # Install other dependencies\n    pip install captcha pandas pillow\n    ```\n\n2.  **Generate Dataset**: If you haven't generated your synthetic data yet, run the data generation script located in the `src` directory:\n    ```bash\n    cd src\n    python data.py\n    ```\n    This will create 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with the required train/val/test splits.\n\n3.  **Start Training**: You can initiate the full training pipeline by running the main script in the root directory:\n    ```bash\n    python train.py\n    ```\n\n### Pipeline Features:\nAccording to the `README.md` in the `CaptchaOCR` repository, your pipeline includes:\n*   **Automatic Metrics**: Training/validation loss tracking and automatic plot generation in the `Metrics/` folder.\n*   **Early Stopping**: An enhanced mechanism to prevent overfitting.\n*   **Logging**: Comprehensive logs for logits, predictions, and model health.\n*   **Architecture**: A CRNN model (CNN encoder + BiLSTM + LayerNorm + linear output).\n*   **Data Handling**: A custom PyTorch `Dataset` class and a CTC collate function for variable-length sequences.\n\nYou can monitor your progress in real-time via the console, which displays loss and prediction samples as the training proceeds.",
        "The allowed origins for your **IntrusionBackend** project are defined in `knowledge_base\\repos\\IntrusionBackend\\cors.py` within the `configure_cors` function. They are:\n\n*   `https://mohakapoor.in`\n*   `https://sisyphus.mohakapoor.in`\n*   `http://mohakapoor.in`\n*   `http://sisyphus.mohakapoor.in`\n*   `http://localhost:8000`",
        "CORS origins are configured in the `cors.py` file within the `IntrusionBackend` repository. Specifically, the `configure_cors` function defines the `allowed_origins` list.\n\nThe following origins are currently configured:\n* `https://mohakapoor.in`\n* `https://sisyphus.mohakapoor.in`\n* `http://mohakapoor.in`\n* `http://sisyphus.mohakapoor.in`\n* `http://localhost:8000`",
        "Based on the provided documentation for the **IntrusionBackend** project, environment variables are loaded from a `.env` file.\n\nAccording to `knowledge_base\\repos\\IntrusionBackend\\README.md` and `knowledge_base\\repos\\IntrusionBackend\\documentation.md`, you should create a `.env` file in the root of your project containing the following keys:\n\n*   `TOKEN`\n*   `PATH_LIGHTGBM`\n*   `PATH_XGBOOST`\n*   `PATH_PCA`\n*   `PATH_STANDARD`\n*   `PATH_MINMAX`\n\nYou can initialize this file by running `cp .env.example .env` and then filling in your specific values.",
        "The Docker configuration for the **IntrusionBackend** is located in the `docker-compose.yml` file within the repository.\n\nAccording to the file `knowledge_base/repos/IntrusionBackend/docker-compose.yml`, the configuration defines a service named `intrusion-tracker` that builds from the current directory, maps port `8000`, and utilizes an `.env` file for environment variables.",
        "Based on the provided codebase context, there is no information regarding the definition or configuration of GitHub Actions. The repositories (`CaptchaOCR`, `HermesGPT`, and `IntrusionBackend`) do not contain any `.github` folders or workflow files in their file structures.",
        "Based on the provided codebase, the configuration for preprocessing and scaling depends on which repository you are referring to:\n\n### **IntrusionBackend**\nIn the `IntrusionBackend` repository, data preprocessing and scaling logic is centralized in **`utils.py`**. \n\n*   **Scaling:** The `documentation.md` file notes that `utils.py` handles scaling (MinMax/Standard) and that the **`scalers/`** directory contains the actual transformation models (such as PCA and Scalers) used for data normalization.\n*   **Usage:** In **`predict.py`**, the functions `predict_attack` and `predict_attack_by_idx` explicitly call `scale_unsupervised(raw_sample)` and `scale_supervised(raw_sample)` to prepare data before passing it to the models.\n\n### **CaptchaOCR**\nIn the `CaptchaOCR` repository, preprocessing is handled differently:\n\n*   **Preprocessing:** The `inference.py` file uses a `preprocess_image(image_path)` function to prepare images before they are passed to the model for prediction.\n*   **Development Workflow:** According to the `README.md` file, the first step in your development workflow is to \"Implement Dataset class\" to handle loading and preprocessing images.\n\nIf you are looking for specific configuration parameters (like scaling factors or normalization constants), these are typically stored within the serialized files located in the `IntrusionBackend/scalers/` directory or handled via the `Dataset` class implementation in `CaptchaOCR`.",
        "Based on the provided codebase, there is no explicit code implementation of email rate limits (such as a specific rate-limiting algorithm or sleep timer logic) within the functions provided.\n\nHowever, the **README.md** file for the `HermesGPT` repository mentions the following under its **Features** section:\n\n> \"- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.\"\n\nWhile the `get_recruiters` function in `hermesgpt.py` supports a `batch_size` parameter (defaulting to 40), the actual logic for the \"randomized delays\" mentioned in the documentation is not present in the provided snippets.",
        "Based on the provided codebase for the **CaptchaOCR** repository, the inference process is handled by the `inference.py` script. Here is how it works:\n\n### 1. Preprocessing (`preprocess_image`)\nBefore the model can process an image, it must be prepared to match the training format:\n*   **Loading**: The image is loaded from the specified path (supporting grayscale or color based on configuration).\n*   **Resizing**: The image is resized to the target dimensions (`cfg.W_max`, `cfg.H`).\n*   **Normalization**: The pixel values are converted to a float tensor and normalized by dividing by 255.0.\n*   **Dimension Adjustment**: The tensor is reshaped to include batch and channel dimensions (e.g., `[1, 1, H, W]` for grayscale) to be compatible with the model's input requirements.\n\n### 2. Inference Execution (`predict_captcha`)\nOnce the image is preprocessed, the `predict_captcha` function performs the following:\n*   **Device Management**: The image tensor is moved to the appropriate device (CPU or GPU).\n*   **Forward Pass**: The model performs a forward pass on the image tensor to generate `logits`.\n*   **Decoding**: The `ctc_greedy_decode` function is used to convert the model's output logits into the final predicted CAPTCHA string.\n\n### 3. Usage and Evaluation\nAccording to the `README.md`, the inference pipeline is designed to:\n*   **Automatic Loading**: The `inference.py` script automatically loads the best-trained model.\n*   **Evaluation**: It generates test CAPTCHAs to evaluate performance.\n*   **Metrics**: It calculates and displays both overall and character-level accuracy.\n*   **Visualization**: It creates visualization plots and saves them in the `Metrics` folder.\n\nTo run the inference pipeline, you can execute:\n```bash\npython inference.py\n```",
        "In your project, the WebSocket streaming functionality is handled by the `websocket_stream` function located in `router.py`. It is designed to stream datasets in batches of 100 rows while providing real-time telemetry.\n\nHere is how the process works:\n\n### 1. Connection and Authentication\n*   **Endpoint**: The service is available at `WS /intrusiondetection/ws/stream`.\n*   **Initialization**: Upon connecting, the client must send a JSON message containing a `command` (\"start\"), a `token` for authentication, and an optional `start_at` index.\n*   **Security**: The server validates the provided token against a stored `API_TOKEN` before allowing the stream to begin.\n\n### 2. Data Processing and Inference\n*   **Batching**: The server iterates through the dataset in batches of 100 rows.\n*   **Inference**: For each row, the server uses `predict.predict_attack_by_idx` (executed in an executor to avoid blocking the event loop) to run the hierarchical ML pipeline.\n*   **Statistics Tracking**: As it processes, the server maintains a `stats` dictionary that tracks:\n    *   Total processed rows and correct predictions (using LightGBM for accuracy tracking).\n    *   Counts for actual vs. predicted classes.\n    *   Latency metrics for each model (Autoencoder, Isolation Forest, FFNN, LightGBM, LogReg, XGBoost) and the total pipeline.\n\n### 3. Real-time Feedback\n*   **Batch Updates**: After each batch of 100, the server sends a JSON message back to the client containing the batch data, the current accuracy, and the total number of processed rows.\n*   **Latency**: The server includes an `asyncio.sleep(0.01)` between batches to manage flow.\n\n### 4. Completion\n*   **Summary**: Once the entire dataset has been processed, the server sends a final `summary` message. This includes the final accuracy, total counts, and the calculated average latencies for every model in the pipeline.\n*   **Cleanup**: The WebSocket connection is automatically closed by the server once the stream is complete.\n\nFor more details on the API structure, you can refer to `documentation.md`, and for the specific implementation logic, see `router.py`.",
        "Based on the provided codebase, the process for an image traveling from upload to prediction depends on whether you are using the **CaptchaOCR** web interface or the command-line inference script.\n\n### 1. Web Interface (CaptchaOCR)\nIn `knowledge_base\\repos\\CaptchaOCR\\app.py`, the flow is as follows:\n*   **Generation/Upload:** The user clicks \"Generate CAPTCHA\" (or potentially uploads an image, though the code notes \"no upload option anymore\"). The `ui_generate` function (referenced in `gen_btn.click`) generates the image and returns an internal file path.\n*   **Path Handling:** The internal path is stored in a hidden `path_box` component.\n*   **Triggering Prediction:** When the user clicks the \"Solve\" button, the `ui_solve` function is triggered.\n*   **Prediction:** `ui_solve` uses the internal path to load the image, preprocess it, and pass it to the `predict_captcha` function.\n\n### 2. Command-Line Inference (CaptchaOCR)\nIn `knowledge_base\\repos\\CaptchaOCR\\inference.py`, the flow is:\n*   **Generation:** The `main()` function generates test CAPTCHAs using `generate_test_captcha` and stores their file paths in a list.\n*   **Preprocessing:** Inside the inference loop, the code calls `preprocess_image(image_path)`, which converts the image file into an `image_tensor`.\n*   **Inference:** The `image_tensor` is passed to `predict_captcha(model, image_tensor, device)`.\n*   **Execution:** Inside `predict_captcha`:\n    1.  The tensor is moved to the appropriate `device` (CPU or GPU).\n    2.  The model performs a forward pass to generate `logits`.\n    3.  The `ctc_greedy_decode` function decodes the `logits` into the final text prediction.\n\n### 3. Intrusion Detection (IntrusionBackend)\nIf you are referring to the `IntrusionBackend` repository, the process is different as it handles data streams rather than image files:\n*   **API/WebSocket:** Data is sent via `POST` requests to specific endpoints (e.g., `/predict/logreg`) or streamed via `WS /intrusiondetection/ws/stream`.\n*   **Processing:** The backend processes the data (e.g., `predict._predict_lightgbm(raw_sample)`) and returns the prediction result.\n\n**Summary of the core prediction logic:**\nRegardless of the entry point, the actual prediction logic for CAPTCHAs is centralized in `predict_captcha` in `inference.py`, which relies on `torch.no_grad()` for efficiency and `ctc_greedy_decode` to interpret the model's output.",
        "Based on the provided codebase, WebSocket clients are managed through the `websocket_stream` function located in `router.py`. Here is how the management process works:\n\n1.  **Connection and Authentication**:\n    *   The client connects to the endpoint `WS /intrusiondetection/ws/stream`.\n    *   Upon connection, the server calls `await websocket.accept()`.\n    *   The client must send an initialization JSON message containing a `command` (\"start\"), a `token` for authentication, and an optional `start_at` index.\n    *   If the provided token does not match the `API_TOKEN`, the server sends an \"Unauthorized\" error, closes the connection with code `1008`, and terminates the function.\n\n2.  **Streaming Process**:\n    *   Once authenticated, the server processes the dataset in batches of 100 rows.\n    *   It uses `asyncio.get_event_loop()` to run inference tasks in an executor to avoid blocking the event loop.\n    *   During the stream, the server sends real-time updates to the client containing batch data and current accuracy statistics.\n    *   An `await asyncio.sleep(0.01)` is included between batches, likely to manage resource usage.\n\n3.  **Completion and Error Handling**:\n    *   **Summary**: Once all rows are processed, the server sends a final summary message containing total accuracy, counts, and average latencies for all models.\n    *   **Closure**: After sending the summary, the server explicitly closes the connection with code `1000`.\n    *   **Exceptions**: The function includes a `try-except` block to handle `WebSocketDisconnect` (client disconnection) and general exceptions, where it logs the error and closes the connection with code `1011` if an unexpected error occurs.",
        "Based on the provided documentation for the **CaptchaOCR** repository, the training pipeline is designed as an end-to-end system that utilizes synthetic data and a CRNN architecture. Here is how it works:\n\n### 1. Data Preparation\n*   **Generation**: You generate synthetic CAPTCHA images using `src/data.py`. This script creates 10,000 images (with 8k train and 1k val splits) stored in `Dataset_test/captchas/`.\n*   **Preprocessing**: The `PyTorch` dataset class handles image loading and preprocessing, including resizing using `cv2`.\n*   **Batching**: The pipeline uses a custom **CTC Collate Function** to handle batching for variable-length sequences.\n\n### 2. Model Architecture\n*   The system uses a **CRNN (Convolutional Recurrent Neural Network)** consisting of a CNN encoder, BiLSTM layers, LayerNorm, and a linear output layer.\n*   It is configured to produce an output shape of `64 \u00d7 batch \u00d7 63` (based on image dimensions of 60x256 and 63 classes including the CTC blank token).\n\n### 3. Training Process\n*   **Execution**: The training is initiated by running `python train.py`.\n*   **Loss Function**: It employs **CTC (Connectionist Temporal Classification)** loss, which is suitable for sequence recognition tasks.\n*   **Monitoring & Optimization**:\n    *   The pipeline includes **Early Stopping** to automatically prevent overfitting.\n    *   It features real-time tracking of loss and prediction samples.\n    *   It automatically generates visualizations (plots) of training and validation losses in the `Metrics/` folder.\n*   **Debugging**: The pipeline includes comprehensive logging of logits, predictions, and model health to ensure the training loop remains stable.\n\n### 4. Current Status\nAccording to the `README.md`, the training pipeline is currently stable with \"excellent loss convergence.\" As of the latest report, the model has reached Epoch 8 with a validation loss of 0.1782 and is achieving 75-100% overall accuracy.",
        "Based on the provided codebase context, there is no mention of any Rust projects. The repositories identified are:\n\n*   **HermesGPT**\n*   **IntrusionBackend** (which uses Python-based libraries such as `fastapi`, `pandas`, `scikit-learn`, `lightgbm`, `xgboost`, and `torch`)\n*   **CaptchaOCR**\n\nThe information regarding a Rust project is unavailable in the provided context.",
        "Based on the provided codebase context for both **IntrusionBackend** and **HermesGPT**, there is no mention of Kubernetes. The documentation and file structures focus on Python-based backend services, WebSocket streaming, and API endpoints, but do not reference container orchestration or Kubernetes configuration files.",
        "Based on the provided codebase for the `IntrusionBackend` repository, there is no mention or implementation of **Redis Streams**.\n\nThe backend handles data streaming via **WebSockets** (`WS /intrusiondetection/ws/stream`), which processes data in batches of 100 rows directly from the dataset (as seen in `router.py` and `documentation.md`). The flow processing logic is handled by a `FlowTable` class in `pcap_to_cicids.py`, which manages flows in memory using dictionaries and lists rather than an external message broker like Redis.",
        "Based on the provided codebase context, there is no mention of GraphQL in any of the repositories (IntrusionBackend, HermesGPT, or CaptchaOCR). Therefore, it appears you have not implemented GraphQL.",
        "Based on the provided codebase context, the repository **IntrusionBackend** uses FastAPI.\n\nThis is confirmed by:\n*   **`knowledge_base\\repos\\IntrusionBackend\\cors.py`**: Imports `FastAPI` and `CORSMiddleware`.\n*   **`knowledge_base\\repos\\IntrusionBackend\\router.py`**: Initializes the application with `app = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")`.\n*   **`knowledge_base\\repos\\IntrusionBackend\\documentation.md`**: States that the \"Intrusion Tracker Backend\" is powered by FastAPI.\n*   **`knowledge_base/repos/IntrusionBackend/manifest.json`**: Lists \"fastapi\" as a topic for the repository.",
        "Based on the provided codebase context, the project that uses Gemini is **HermesGPT**.\n\nAccording to `knowledge_base\\repos\\HermesGPT\\hermesgpt.py` (lines 88-89), the project configures the Google Generative AI SDK and initializes a chat session using the `gemini-2.0-flash` model. Additionally, the `README.md` for HermesGPT confirms that it uses Gemini AI to generate tailored cold emails.",
        "Based on the provided codebase context, the following projects use PyTorch:\n\n*   **CaptchaOCR**: This project uses PyTorch with CUDA support for its CRNN (CNN + RNN) architecture and sequence recognition (found in `knowledge_base\\repos\\CaptchaOCR\\README.md`).\n*   **IntrusionBackend**: This project lists PyTorch as part of its ML/DL tech stack (found in `knowledge_base\\repos\\IntrusionBackend\\README.md`).",
        "Based on the provided codebase context, the following project exposes a REST API:\n\n*   **IntrusionBackend**: The file `knowledge_base\\repos\\IntrusionBackend\\router.py` contains an endpoint `api_name` that returns `{\"api_name\": \"Intrusion Detection API\"}`. Additionally, the `README.md` for this project mentions that full API specifications can be found in `documentation.md`.\n\nThe provided context for **HermesGPT** does not explicitly mention a REST API; it describes setup instructions involving the Gmail API, Gemini AI API, and database configuration.",
        "The `generate_captcha` function is defined in `src/generateCaptcha.py` (lines 104-170). It is designed to generate a single enhanced CAPTCHA image.\n\n### Function Signature\n```python\ndef generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None)\n```\n\n### Key Details:\n*   **Parameters:**\n    *   `text` (str, optional): The text to render. If `None`, it generates random text based on `CAPTCHA_LEN_LOWER_LIMIT` (5) and `CAPTCHA_LEN_UPPER_LIMIT` (7).\n    *   `width` (int): Image width (defaults to `IMG_WIDTH` = 256).\n    *   `height` (int): Image height (defaults to `IMG_HEIGHT` = 60).\n    *   `save_path` (str, optional): If provided, the image is saved to this path and the path is returned. If `None`, the function returns a `PIL Image` object.\n*   **Functionality:**\n    *   It randomizes the background (solid or gradient).\n    *   It uses `captcha.image.ImageCaptcha` for base rendering.\n    *   It applies several enhancements, including rotation, perspective warping, interference (lines/dots), noise, blur, JPEG recompression, and optional low-contrast adjustments.\n    *   If `GRAYSCALE` is set to `True` (default), the final image is converted to grayscale.\n\n### Usage Examples in the Codebase:\n*   **In `app.py`:** Used within `ui_generate` to create CAPTCHAs for the UI using `cfg.W_max` and `cfg.H`.\n*   **In `inference.py`:** Used within `generate_test_captcha` to generate test images.\n*   **In `src/generateCaptcha.py`:** The `if __name__ == \"__main__\":` block demonstrates generating a sample CAPTCHA with specific text (\"HELLO\") and a save path.",
        "Based on the provided codebase, here is the information regarding **Dataset Generation** for your project:\n\n### Overview\nYour project uses a synthetic CAPTCHA generation system to create training data for the OCR model.\n\n### Key Components\n*   **Generation Logic**: The generation utility is located in `knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py`. It uses enhanced rendering to create images with the following default specifications:\n    *   **Image Dimensions**: 256x60 pixels (`IMG_WIDTH`, `IMG_HEIGHT`).\n    *   **Character Set**: Alphanumeric (`string.ascii_letters + string.digits`).\n    *   **Length**: Randomly generated between 5 and 7 characters (`CAPTCHA_LEN_LOWER_LIMIT`, `CAPTCHA_LEN_UPPER_LIMIT`).\n*   **Test Generation**: The `inference.py` file contains a `generate_test_captcha` function that utilizes the generation logic to create and save test images to a configured results directory.\n\n### Current Status\nAccording to the `README.md` file, the dataset generation component is **completed** and includes:\n*   **Synthetic CAPTCHA creation** with defined train, validation, and test splits (8k training images and 1k validation images).\n*   **PyTorch Dataset Class** implementation, which handles image loading and preprocessing using `cv2` resizing.\n*   **Vocabulary System** that supports character encoding/decoding with CTC blank token support (totaling 63 classes).\n*   **CTC Collate Function** to handle proper batching for variable-length sequences.",
        "Based on the provided codebase, there is no single function named `predict_intrusion`. However, the system provides several ways to perform intrusion detection predictions through the API and internal modules:\n\n### 1. API Endpoints\nThe `IntrusionBackend` provides a hierarchical pipeline and direct model access:\n\n*   **Hybrid Detection (Recommended):** `POST /intrusiondetection/predict/hybrid`\n    *   Uses a hierarchical pipeline: **Anomaly detection (Unsupervised)** followed by **Classification (Supervised)**.\n    *   If the Autoencoder or Isolation Forest flags the flow, supervised models (like LightGBM) are invoked, with LightGBM acting as the final \"Veto.\"\n*   **Prediction By Index:** `POST /intrusiondetection/predict/hybrid_by_index`\n    *   Used for testing samples from the `unscaled_test.parquet` dataset by providing an `index`.\n*   **Direct Model Endpoints:**\n    *   `POST /predict/logreg`\n    *   `POST /predict/lightgbm`\n    *   `POST /predict/ffnn`\n    *   `POST /predict/autoencoder`\n    *   `POST /predict/isolationForest`\n    *   `POST /predict/xgboost`\n\n### 2. Internal Logic\n*   **`predict.predict_attack_by_idx(idx)`**: Used in `stats.py` to evaluate the dataset. It runs the hierarchical pipeline and determines if a sample is an attack based on the LightGBM \"Veto\" logic.\n*   **`predict._predict_isolation_forest(raw_sample)`**: An internal function used by the `predict_isolation_forest_endpoint` in `router.py` to perform isolation forest predictions.\n\nIf you are looking to implement or call a prediction, the **Hybrid Detection** endpoint is the recommended approach as defined in `knowledge_base\\repos\\IntrusionBackend\\documentation.md`.",
        "**HermesGPT** is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities.\n\n### Key Features\n*   **AI-Generated Emails:** Uses Gemini AI to create personalized cold emails.\n*   **Database Management:** Tracks recruiter information and contact status using PostgreSQL.\n*   **Email Automation:** Integrates with the Gmail API for automated sending.\n*   **Verification:** Includes email verification capabilities.\n\n### Project Structure\nAccording to the `portfolio_graph`, the repository contains the following files:\n*   `hermesgpt.py`: Contains the core logic, including the `connect_db` function.\n*   `manifest.json`: Metadata for the repository.\n*   `README.md`: Setup instructions and project overview.\n*   `requirements.txt`: Project dependencies.\n\n### Database Configuration\nThe project uses a PostgreSQL database named `hermesgpt`. The `connect_db` function in `hermesgpt.py` is configured with the following defaults:\n*   **User:** `postgres`\n*   **Password:** `1234`\n*   **Host:** `localhost`\n*   **Port:** `5432`\n\nThe database requires a `recruiters` table with the following schema:\n```sql\nCREATE TABLE recruiters (\n    email TEXT PRIMARY KEY,\n    recruiter_name TEXT,\n    company_name TEXT,\n    role TEXT,\n    contacted BOOLEAN DEFAULT FALSE\n);\n```\n\n### Getting Started\n1.  **Clone the repo:** `git clone https://github.com/your-username/HermesGPT.git`\n2.  **Install dependencies:** `pip install -r requirements.txt`\n3.  **Setup:** Configure your PostgreSQL database, place your `credentials.json` (for Gmail API) in the root directory, and add your Gemini AI API key to the `API_KEY` variable.\n4.  **Data:** Prepare a `recruiters.csv` file with columns for Email, Name, Company, and Title."
    ],
    "contexts": [
        [
            {
                "text": "### \u2705 Completed Components\n- **Dataset Generation**: Synthetic CAPTCHA creation with train/val/test splits (8k train, 1k val)\n- **Configuration**: Centralized config with image dimensions and training parameters\n- **Vocabulary System**: Character encoding/decoding with CTC blank token support (63 classes)\n- **CTC Collate Function**: Proper batching for variable-length sequences\n- **CTC Decoding**: Greedy decode for inference\n- **PyTorch Dataset Class**: Image loading and preprocessing with proper cv2 resizing\n- **CRNN Model**: CNN encoder + BiLSTM + LayerNorm + linear output (working!)\n- **Training Loop**: Complete epoch-based training pipeline with validation\n- **Metrics & Plotting**: Training/validation loss tracking with beautiful visualizations\n- **Debugging Tools**: Comprehensive logging of logits, predictions, and model health  \n### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 3,
                    "size": 945,
                    "_id": "cc52b2b4-6738-5973-9c50-29fc8882ca66",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Environment Setup\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```  \n### 2. Generate Training Dataset\n```bash\ncd src\npython data.py\n```\nThis creates 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with proper train/val/test splits.  \n### 3. Start Training\n```bash\npython train.py\n```\nThis starts the full training pipeline with automatic metrics generation.  \n### 4. Monitor Progress\nTraining will show:\n- Real-time loss and prediction samples\n- Automatic plot generation in `Metrics/` folder\n- Comprehensive training logs and summaries",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\ude80 Quick Start",
                    "symbol": "\ud83d\ude80 Quick Start",
                    "chunk_idx": 7,
                    "size": 721,
                    "_id": "3b357f42-2155-5453-a29c-795d0e1c9c09",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "A PyTorch-based CAPTCHA recognition system using synthetic data generation and CTC-based sequence modeling. Built with deep learning techniques, achieving high accuracy on complex text recognition tasks.",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "None",
                    "symbol": "CAPTCHA OCR Project",
                    "chunk_idx": 1,
                    "size": 203,
                    "_id": "89c221f0-2ced-5f9a-9c1d-e200c57f37f5",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "class CaptchaDataset(torch.utils.data.Dataset):\n    def __init__(self,folder:str):\n        self.data_root = cfg.data_root        \n        df = pd.read_csv(f\"{self.data_root}/{folder}/labels.csv\")\n        self.data = []\n        for _,row in df.iterrows():\n            filename = row['filename']\n            label = row['label']\n            img_path = f\"{self.data_root}/{folder}/{row['filename']}\"\n            \n            # Check if file actually exists\n            if os.path.exists(img_path):\n                self.data.append((img_path,label,folder))\n            else:\n                print(f\"Warning: Image file not found: {img_path}\")\n        \n        print(f\"Loaded {len(self.data)} valid images from {folder}\")\n        self.img_dim = (cfg.W_max, cfg.H)  # cv2.resize expects (width, height)\n\n    def __len__(self):\n        return len(self.data)\n\n    def __getitem__(self,idx):\n        img_path, label_string,folder = self.data[idx]\n        \n        # Load image with error checking\n        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE if cfg.grayscale else cv2.IMREAD_COLOR)\n        \n        if img is None:\n            raise ValueError(f\"Failed to load image: {img_path}\")\n        \n        img = cv2.resize(img, self.img_dim)\n        img_tensor = torch.from_numpy(img).float()/255.0  # Normalize to [0,1]\n        img_tensor = img_tensor.unsqueeze(0)  # Add channel dimension\n        return img_tensor, label_string, img_path",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\captcha_dataset.py",
                    "filename": "captcha_dataset.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "class",
                    "start_line": 10,
                    "end_line": 44,
                    "symbol": "CaptchaDataset",
                    "chunk_idx": 1,
                    "size": 1434,
                    "_id": "060f3e08-63f7-549a-a978-6f5b006769d3",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None):\n    \"\"\"\n    Generate a single enhanced CAPTCHA image.\n    \n    Args:\n        text (str, optional): Text to render. If None, generates random text.\n        width (int): Image width\n        height (int): Image height\n        save_path (str, optional): Path to save the image. If None, returns PIL Image.\n    \n    Returns:\n        PIL Image if save_path is None, otherwise saves and returns the path\n    \"\"\"\n    # Generate random text if none provided\n    if text is None:\n        text = ''.join(random.choices(CHARS, k=random.randint(CAPTCHA_LEN_LOWER_LIMIT, CAPTCHA_LEN_UPPER_LIMIT)))\n    \n    # Randomize basic style\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    \n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # Use ImageCaptcha for base text rendering\n    from captcha.image import ImageCaptcha\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n    \n    # Draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # Apply enhancements\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # Perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # Add interference\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # Noise + blur + JPEG recompression\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # Optional low contrast\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    # Save or return\n    if save_path:\n        base.save(save_path)\n        return save_path\n    else:\n        return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 104,
                    "end_line": 170,
                    "symbol": "generate_captcha",
                    "chunk_idx": 7,
                    "size": 2362,
                    "_id": "5961a050-0f46-5993-aadb-d341153dadc1",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def render_with_variation(text, width=IMG_WIDTH, height=IMG_HEIGHT):\n    # randomize basic style knobs\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # ImageCaptcha accepts fonts via fonts arg; here we keep default but jitter spacing\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n\n    # draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # quick contrast tweak: recolor foreground by compositing text mask if needed\n    # For minimal change, we stick with base and apply light warps/noise\n    # mild rotation/shear\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # draw interference over the image\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # light noise + blur + jpeg recompress to add artifacts\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # optional low contrast: 20% chance to darken bg and lighten fg a bit\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\data.py",
                    "filename": "data.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 100,
                    "end_line": 145,
                    "symbol": "render_with_variation",
                    "chunk_idx": 7,
                    "size": 1883,
                    "_id": "edf9c02e-26d0-5908-ba80-89e641ae5441",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Implement Dataset class** - Load and preprocess images\n2. **Build CRNN model** - CNN + BiLSTM architecture\n3. **Create training loop** - With validation and checkpoints\n4. **Add metrics** - CER and accuracy tracking\n5. **Test on small dataset** - Verify everything works\n6. **Scale to full dataset** - Train on Colab",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udee0\ufe0f Development Workflow",
                    "symbol": "\ud83d\udee0\ufe0f Development Workflow",
                    "chunk_idx": 15,
                    "size": 321,
                    "_id": "60bcb358-3110-5090-a80c-cf9343a2c6c2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This is a learning project! Feel free to:\n- Ask questions about implementation details\n- Experiment with different architectures\n- Improve the data generation or training pipeline",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83e\udd1d Contributing",
                    "symbol": "\ud83e\udd1d Contributing",
                    "chunk_idx": 16,
                    "size": 179,
                    "_id": "0bb57d4e-10c5-5bbe-83d6-74f9591fda94",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def preprocess_image(image_path, target_size=(cfg.W_max, cfg.H)):\n    \"\"\"Preprocess image for inference (same as training).\"\"\"\n    # Load image\n    if not os.path.exists(image_path):\n        raise FileNotFoundError(f\"Image not found: {image_path}\")\n    \n    # Read and preprocess\n    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE if cfg.grayscale else cv2.IMREAD_COLOR)\n    if img is None:\n        raise ValueError(f\"Failed to load image: {image_path}\")\n    \n    # Resize to target dimensions\n    img = cv2.resize(img, target_size)\n    \n    # Convert to tensor and normalize\n    img_tensor = torch.from_numpy(img).float() / 255.0\n    \n    # Add batch and channel dimensions\n    if cfg.grayscale:\n        img_tensor = img_tensor.unsqueeze(0).unsqueeze(0)  # [1, 1, H, W]\n    else:\n        img_tensor = img_tensor.permute(2, 0, 1).unsqueeze(0)  # [1, 3, H, W]\n    \n    return img_tensor",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 33,
                    "end_line": 56,
                    "symbol": "preprocess_image",
                    "chunk_idx": 2,
                    "size": 888,
                    "_id": "3d9a8566-e6a1-5788-985a-649fa1569bbc",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "with gr.Blocks(title=\"CAPTCHA OCR (checkpoint)\") as demo:\n    gr.Markdown(\"## CAPTCHA OCR \")\n\n    with gr.Row():\n        # Left column: Generate button + Solve button stacked vertically\n        with gr.Column(scale=1):\n            gen_btn = gr.Button(\"Generate CAPTCHA\", variant=\"primary\")\n            solve_btn = gr.Button(\"Solve\", interactive=False, variant=\"secondary\")\n        \n        # Right column: Ground Truth\n        gt_out = gr.Textbox(label=\"Ground Truth\", interactive=False, text_align=\"center\")\n\n    with gr.Row():\n        img_out = gr.Image(label=\"Generated CAPTCHA\", type=\"pil\")\n        path_box = gr.Textbox(label=\"Internal Path\", interactive=False, visible=False)\n\n    # Prediction row split into two columns\n    with gr.Row():\n        accuracy_out = gr.Textbox(label=\"Character Accuracy\", interactive=False, text_align=\"center\")\n        pred_out = gr.Textbox(label=\"Prediction\", interactive=False, text_align=\"center\")\n\n    # Generate: outputs image, ground truth, path, and enables Solve (green)\n    gen_btn.click(\n        fn=ui_generate,\n        outputs=[img_out, gt_out, path_box, solve_btn],\n    )\n\n    # Solve: only uses the internal path (no upload option anymore)\n    solve_btn.click(\n        fn=ui_solve,\n        inputs=[path_box, gt_out],\n        outputs=[accuracy_out, pred_out],\n    )\nif __name__ == \"__main__\":\n    demo.launch()",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\app.py",
                    "filename": "app.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 66,
                    "end_line": 101,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 1359,
                    "_id": "d33e2103-8a96-5c78-a5ce-4f9aff805aa9",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def main():\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    in_ch = 1 if cfg.grayscale else 3\n\n    print(\"Creating datasets...\")\n    train_ds = CaptchaDataset(\"train\")\n    val_ds = CaptchaDataset(\"val\")\n    \n    print(f\"Training dataset size: {len(train_ds)}\")\n    print(f\"Validation dataset size: {len(val_ds)}\")\n\n    train_dl = DataLoader(train_ds, batch_size=cfg.batch_size, shuffle=True, \n                          num_workers=cfg.num_workers, pin_memory=True, \n                          drop_last=True, collate_fn=ctc_collate)\n    val_dl = DataLoader(val_ds, batch_size=cfg.batch_size, shuffle=False, \n                        num_workers=cfg.num_workers, pin_memory=True, \n                        drop_last=True, collate_fn=ctc_collate)\n\n    # # Test training data\n    # print(\"\\nTesting training data...\")\n    # for batch in train_dl:\n    #     images, targets_flat, target_lengths, input_lengths, paths = batch\n    #     print(f\"Training batch shape: {images.shape}\")\n    #     print(f\"Sample labels: {targets_flat[:10]}\")\n    #     break\n\n    # # Test validation data\n    # print(\"\\nTesting validation data...\")\n    # try:\n    #     for batch in val_dl:\n    #         images, targets_flat, target_lengths, input_lengths, paths = batch\n    #         print(f\"Validation batch shape: {images.shape}\")\n    #         print(f\"Sample labels: {targets_flat[:10]}\")\n    #         break\n    # except Exception as e:\n    #     print(f\"Error in validation data: {e}\")\n    #     print(\"This suggests there are issues with some validation images\")\n\n    model = CRNN(vocab_size=vocab_size()).to(device)\n    criterion = nn.CTCLoss(blank=0, zero_infinity=True)\n    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n    scaler = torch.amp.GradScaler('cuda', enabled=cfg.amp and device.type == \"cuda\")\n\n    model.train()\n    steps = 200\n    it = iter(train_dl)\n    for step in range(1,steps+1):\n        try:\n            images, targets_flat, target_lengths, input_lengths, paths = next(it)\n        except StopIteration:\n            it = iter(train_dl)\n            images, targets_flat, target_lengths, input_lengths, paths = next(it)\n        \n        images = images.to(device)\n        targets_flat = targets_flat.to(device)\n        target_lengths = target_lengths.to(device)\n        input_lengths = input_lengths.to(device)\n\n        optimizer.zero_grad(set_to_none=True)\n\n        with torch.amp.autocast('cuda', enabled=scaler.is_enabled()):\n            logits = model(images)\n            log_probs = logits.log_softmax(dim=-1)\n            loss = criterion(log_probs,targets_flat,input_lengths,target_lengths)\n        scaler.scale(loss).backward()\n        scaler.step(optimizer)\n        scaler.update()\n\n\n        if step % 20 == 0:\n            print(f\"step {step}/{steps} - loss {loss.item():.4f}\")\n\n    model.eval()\n    with torch.no_grad():\n        images, targets_flat, target_lengths, input_lengths, paths = next(iter(val_dl))\n        images = images.to(device)\n        logits = model(images)\n        preds = ctc_greedy_decode(logits)\n\n    print(\"Sanity check complete\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\train_sanity.py",
                    "filename": "train_sanity.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 12,
                    "end_line": 91,
                    "symbol": "main",
                    "chunk_idx": 1,
                    "size": 3103,
                    "_id": "ab8ca622-4954-58e4-982e-a7857a681d19",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "import os\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom src.config import cfg\nfrom src.collate import ctc_collate\nfrom src.captcha_dataset import CaptchaDataset\nfrom src.vocab import vocab_size, ctc_greedy_decode, decode_indices, itos\nfrom src.plotting import TrainingMetrics\nfrom src.model_crnn import CRNN\nimport difflib",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\train.py",
                    "filename": "train.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 11,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 356,
                    "_id": "307f7cee-e92d-5c12-beea-d71623f57153",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "import os\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom src.config import cfg\nfrom src.collate import ctc_collate\nfrom src.captcha_dataset import CaptchaDataset\nfrom src.vocab import vocab_size, ctc_greedy_decode\nfrom src.model_crnn import CRNN",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\train_sanity.py",
                    "filename": "train_sanity.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 9,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 278,
                    "_id": "3d494ab3-9ece-5ec7-9d22-6f8d053ba66e",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def ctc_collate(batch: List[Tuple[torch.Tensor, str, str]]):\n    \"\"\"\n    batch: list of (image_tensor [C,H,W_max], label_str, rel_path)\n    returns:\n      images: [B,C,H,W_max]\n      targets_flat: [sum(len(label_i))]\n      target_lengths: [B]\n      input_lengths: [B]  (all equal if same W_max/stride)\n      rel_paths: list[str]\n    \"\"\"\n\n    images = torch.stack([item[0] for item in batch],dim =0)\n\n    labels = [item[1] for item in batch]\n    encoded = [torch.tensor(encode_text(t),dtype = torch.long) for t in labels]\n    target_lengths = torch.tensor([len(t) for t in encoded],dtype = torch.long)\n    if len(encoded) > 0:\n        targets_flat = torch.cat(encoded,dim = 0)\n    else:\n        targets_flat = torch.empty(0,dtype = torch.long)\n\n    \n    B, C, H, W = images.shape\n    \n    input_len = W // cfg.total_stride\n    input_lengths = torch.full((B,), input_len, dtype=torch.long)\n\n    rel_paths = [item[2] for item in batch]\n    return images, targets_flat, target_lengths, input_lengths, rel_paths    ",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\collate.py",
                    "filename": "collate.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 6,
                    "end_line": 34,
                    "symbol": "ctc_collate",
                    "chunk_idx": 1,
                    "size": 1010,
                    "_id": "d64dc2bc-d637-5702-b166-478f852d2aa7",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Decoding**: Greedy CTC decode with duplicate removal  \n### Data Pipeline\n- **Images**: Grayscale, normalized to [0,1], proper cv2 resizing\n- **Labels**: CSV with filename and text label\n- **Batching**: Variable-length sequences with custom CTC collate function\n- **Debugging**: Real-time monitoring of logits, blank probability, predictions",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udd2c Technical Details",
                    "symbol": "\ud83d\udd2c Technical Details",
                    "chunk_idx": 13,
                    "size": 344,
                    "_id": "e2a53fc3-9830-52b8-aaf9-fca6ba1baef7",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "import os\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom src.config import cfg\nfrom src.collate import ctc_collate\nfrom src.captcha_dataset import CaptchaDataset\nfrom src.vocab import vocab_size, ctc_greedy_decode\nfrom src.model_crnn import CRNN",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\train_sanity.py",
                    "filename": "train_sanity.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 9,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 278,
                    "_id": "3d494ab3-9ece-5ec7-9d22-6f8d053ba66e",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "import os\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nfrom src.config import cfg\nfrom src.collate import ctc_collate\nfrom src.captcha_dataset import CaptchaDataset\nfrom src.vocab import vocab_size, ctc_greedy_decode, decode_indices, itos\nfrom src.plotting import TrainingMetrics\nfrom src.model_crnn import CRNN\nimport difflib",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\train.py",
                    "filename": "train.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 11,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 356,
                    "_id": "307f7cee-e92d-5c12-beea-d71623f57153",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 Completed Components\n- **Dataset Generation**: Synthetic CAPTCHA creation with train/val/test splits (8k train, 1k val)\n- **Configuration**: Centralized config with image dimensions and training parameters\n- **Vocabulary System**: Character encoding/decoding with CTC blank token support (63 classes)\n- **CTC Collate Function**: Proper batching for variable-length sequences\n- **CTC Decoding**: Greedy decode for inference\n- **PyTorch Dataset Class**: Image loading and preprocessing with proper cv2 resizing\n- **CRNN Model**: CNN encoder + BiLSTM + LayerNorm + linear output (working!)\n- **Training Loop**: Complete epoch-based training pipeline with validation\n- **Metrics & Plotting**: Training/validation loss tracking with beautiful visualizations\n- **Debugging Tools**: Comprehensive logging of logits, predictions, and model health  \n### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 3,
                    "size": 945,
                    "_id": "cc52b2b4-6738-5973-9c50-29fc8882ca66",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "genai.configure(api_key=API_KEY)\nchat = genai.GenerativeModel('gemini-2.0-flash').start_chat(history=[])",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "Module",
                    "start_line": 88,
                    "end_line": 89,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 104,
                    "_id": "1154c6b9-d133-500d-a3f6-38dd38fc41c8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- \ud83d\udcc4 **Resume Parsing**: Loads and processes resume data for personalized email generation.\n- \ud83e\udd16 **AI-Powered Emails**: Uses Gemini AI to generate tailored cold emails.\n- \ud83d\udcec **Automated Email Sending**: Sends emails via Gmail API with attachments.\n- \u2705 **Email Verification**: Uses SMTP and Maileroo API to validate emails before sending.\n- \ud83d\uddc4 **Database Management**: Stores recruiter data in PostgreSQL and tracks outreach progress.\n- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Features",
                    "symbol": "Features",
                    "chunk_idx": 1,
                    "size": 529,
                    "_id": "2b1ec077-3dbf-5a35-8275-b58b0b6597fd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Resume Loading**: The script reads the resume and stores its details in AI memory.\n2. **Recruiter Selection**: Fetches recruiters from the database who haven't been contacted.\n3. **Email Verification**: Ensures the email is valid before sending.\n4. **AI-Generated Email**: Gemini AI crafts a custom email based on the recruiter's details.\n5. **Automated Sending**: Uses Gmail API to send the email with an attached resume.\n6. **Logging & Tracking**: Updates the database to mark recruiters as contacted.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "How It Works",
                    "symbol": "How It Works",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "6dcf5e32-a80e-5849-aa46-ad41296904c3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "import os\nimport base64\nfrom google.oauth2.credentials import Credentials\nfrom google_auth_oauthlib.flow import InstalledAppFlow\nfrom google.auth.transport.requests import Request\nfrom googleapiclient.discovery import build\nfrom email.mime.text import MIMEText\nfrom email.mime.multipart import MIMEMultipart\nfrom email.mime.base import MIMEBase\nfrom email import encoders\nimport time,random\nimport google.generativeai as genai\nimport pathlib\nimport os\nimport psycopg2\nimport pandas as pd\nimport smtplib\nAPI_KEY = \"YOUR_GEMINI_API_KEY\"\nSCOPES = [\"https://www.googleapis.com/auth/gmail.send\"]",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 22,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 590,
                    "_id": "c924aec1-3d7c-50ba-95a0-f9fc943c2685",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def api_name():\n    return {\"api_name\": \"Intrusion Detection API\"}",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 40,
                    "end_line": 41,
                    "symbol": "api_name",
                    "chunk_idx": 5,
                    "size": 72,
                    "_id": "9bf1f6da-08a0-57e2-ad5a-6c00e473cfcc",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_stats():\n    total_rows = len_df()\n    print(f\"Starting evaluation on {total_rows} rows...\")\n    \n    y_true = []\n    y_pred = []\n    \n    # Iterate through the dataset\n    for idx in tqdm(range(total_rows)):\n        try:\n            result = predict.predict_attack_by_idx(idx)\n            \n            actual = result[\"target_class\"]\n            # Logic: If status is Attack Detected, use the LightGBM prediction. \n            # Otherwise, it's Benign (0).\n            if result[\"status\"] == \"Attack Detected\":\n                predicted = result.get(\"supervised\", {}).get(\"lightgbm\", 0)\n            else:\n                predicted = 0\n                \n            y_true.append(actual)\n            y_pred.append(predicted)\n        except Exception as e:\n            print(f\"Error at index {idx}: {e}\")\n            continue\n\n    # 1. Generate Text Report\n    report = classification_report(y_true, y_pred)\n    cm = confusion_matrix(y_true, y_pred)\n    \n    output_text = \"=== CONFUSION MATRIX ===\\n\"\n    output_text += str(cm) + \"\\n\\n\"\n    output_text += \"=== CLASSIFICATION REPORT ===\\n\"\n    output_text += report\n    \n    with open(\"confusion_matrix.txt\", \"w\") as f:\n        f.write(output_text)\n    \n    print(\"\\nText report saved to confusion_matrix.txt\")\n\n    # 2. Generate Heatmap Plot\n    plt.figure(figsize=(12, 10))\n    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n                xticklabels=np.unique(y_true), \n                yticklabels=np.unique(y_true))\n    plt.title(\"Intrusion Detection Confusion Matrix\\n(Hierarchical Pipeline with LGBM Veto)\")\n    plt.xlabel(\"Predicted Class\")\n    plt.ylabel(\"Actual Class\")\n    plt.savefig(\"confusion_matrix.png\", dpi=300)\n    plt.close()\n    \n    print(\"Plot saved to confusion_matrix.png\")\n\n    # 3. Generate Classification Report Heatmap\n    report_dict = classification_report(y_true, y_pred, output_dict=True)\n    # Convert to DataFrame and remove support/averages for plotting\n    report_df = pd.DataFrame(report_dict).iloc[:-1, :].T\n    report_df = report_df.drop(['accuracy', 'macro avg', 'weighted avg'], axis=0, errors='ignore')\n    \n    plt.figure(figsize=(10, 8))\n    sns.heatmap(report_df, annot=True, cmap='Blues')\n    plt.title(\"Classification Report Metrics per Class\")\n    plt.savefig(\"classification_report.png\", dpi=300)\n    plt.close()\n    \n    print(\"Plot saved to classification_report.png\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\stats.py",
                    "filename": "stats.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 14,
                    "end_line": 79,
                    "symbol": "generate_stats",
                    "chunk_idx": 1,
                    "size": 2387,
                    "_id": "efed5473-b5ea-53c4-bf8f-15863894d13a",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def api_name():\n    return {\"api_name\": \"Intrusion Detection API\"}",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 40,
                    "end_line": 41,
                    "symbol": "api_name",
                    "chunk_idx": 5,
                    "size": 72,
                    "_id": "9bf1f6da-08a0-57e2-ad5a-6c00e473cfcc",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **LightGBM (Final Veto)**: A gradient boosting framework that provides the final classification.\n- **FFNN (Feed-Forward Neural Network)**: Deep learning model for multi-class classification.\n- **XGBoost & Logistic Regression**: Additional models used for ensemble verification and comparison.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "System Architecture",
                    "symbol": "System Architecture",
                    "chunk_idx": 2,
                    "size": 300,
                    "_id": "175e6455-9b3c-5c8a-9eaa-f1b643ca0283",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None):\n    \"\"\"\n    Generate a single enhanced CAPTCHA image.\n    \n    Args:\n        text (str, optional): Text to render. If None, generates random text.\n        width (int): Image width\n        height (int): Image height\n        save_path (str, optional): Path to save the image. If None, returns PIL Image.\n    \n    Returns:\n        PIL Image if save_path is None, otherwise saves and returns the path\n    \"\"\"\n    # Generate random text if none provided\n    if text is None:\n        text = ''.join(random.choices(CHARS, k=random.randint(CAPTCHA_LEN_LOWER_LIMIT, CAPTCHA_LEN_UPPER_LIMIT)))\n    \n    # Randomize basic style\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    \n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # Use ImageCaptcha for base text rendering\n    from captcha.image import ImageCaptcha\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n    \n    # Draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # Apply enhancements\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # Perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # Add interference\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # Noise + blur + JPEG recompression\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # Optional low contrast\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    # Save or return\n    if save_path:\n        base.save(save_path)\n        return save_path\n    else:\n        return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 104,
                    "end_line": 170,
                    "symbol": "generate_captcha",
                    "chunk_idx": 7,
                    "size": 2362,
                    "_id": "5961a050-0f46-5993-aadb-d341153dadc1",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def main():\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    in_ch = 1 if cfg.grayscale else 3\n\n    print(\"Creating datasets...\")\n    train_ds = CaptchaDataset(\"train\")\n    val_ds = CaptchaDataset(\"val\")\n    \n    # Debug: Check vocabulary\n    print(f\"Vocabulary size: {vocab_size()}\")\n    print(f\"First 10 characters: {list(cfg.chars)[:10]}\")\n    print(f\"First 10 itos: {itos[:10]}\")\n    \n    print(f\"Training dataset size: {len(train_ds)}\")\n    print(f\"Validation dataset size: {len(val_ds)}\")\n\n    train_dl = DataLoader(train_ds, batch_size=cfg.batch_size, shuffle=True, \n                          num_workers=cfg.num_workers, pin_memory=True, \n                          drop_last=True, collate_fn=ctc_collate)\n    val_dl = DataLoader(val_ds, batch_size=cfg.batch_size, shuffle=False, \n                        num_workers=cfg.num_workers, pin_memory=True, \n                        drop_last=True, collate_fn=ctc_collate)\n\n    model = CRNN(vocab_size=vocab_size()).to(device)\n    \n    # Initialize final layer with small weights for stability\n    with torch.no_grad():\n        torch.nn.init.uniform_(model.fc.weight, -1e-3, 1e-3)\n        torch.nn.init.zeros_(model.fc.bias)\n    \n    criterion = nn.CTCLoss(blank=0, zero_infinity=True)\n    optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-4)\n    scaler = torch.amp.GradScaler('cuda', enabled=False)  # Disable AMP for stability\n\n    # Epoch-based training with scheduler\n    epochs = 40  # Increased for OneCycleLR\n    scheduler = torch.optim.lr_scheduler.OneCycleLR(\n        optimizer, max_lr=3e-4, steps_per_epoch=len(train_dl), epochs=epochs\n    )\n    print(f\"\\nStarting training for {epochs} epochs...\")\n    \n    metrics = TrainingMetrics()\n    \n    # Early stopping setup\n    best_val_loss = float('inf')\n    patience = 5  # Stop if no improvement for 5 epochs\n    patience_counter = 0\n    early_stop = False\n\n    for epoch in range(epochs):\n        # Training phase\n        model.train()\n        total_train_loss = 0\n        num_batches = 0\n        \n        print(f\"\\nEpoch {epoch+1}/{epochs}\")\n        print(\"Training...\")\n        \n        for batch_idx, batch in enumerate(train_dl):\n            images, targets_flat, target_lengths, input_lengths, paths = batch\n            \n            # CTC sanity checks (first batch of each epoch)\n            if batch_idx == 0:\n                assert targets_flat.numel() == target_lengths.sum().item(), \"Target lengths mismatch\"\n                assert torch.all(target_lengths <= input_lengths), \"Target longer than input\"\n                print(f\"    Batch 0 sanity: input_lens={input_lengths[:5].tolist()}, target_lens={target_lengths[:5].tolist()}\")\n                print(f\"    Image stats: min={images.min():.3f}, max={images.max():.3f}, mean={images.mean():.3f}\")\n            \n            \n            images = images.to(device)\n            targets_flat = targets_flat.to(device)\n            target_lengths = target_lengths.to(device)\n            input_lengths = input_lengths.to(device)\n\n            optimizer.zero_grad(set_to_none=True)\n\n            with torch.amp.autocast('cuda', enabled=False):\n                logits = model(images)\n                log_probs = logits.log_softmax(dim=-1)\n                loss = criterion(log_probs, targets_flat, input_lengths, target_lengths)\n            \n            loss.backward()\n            \n            # Gradient clipping to prevent exploding gradients\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n            \n            optimizer.step()\n            scheduler.step()  # OneCycleLR step per batch\n\n            total_train_loss += loss.item()\n            num_batches += 1\n            \n            # Progress update every 50 batches\n            if batch_idx % 50 == 0:\n                print(f\"  Batch {batch_idx}/{len(train_dl)} - Loss: {loss.item():.4f}\")\n        \n        avg_train_loss = total_train_loss / num_batches\n        \n        # Validation phase\n        model.eval()\n        total_val_loss = 0\n        num_val_batches = 0\n        \n        print(\"Validating...\")\n        with torch.no_grad():\n            for batch in val_dl:\n                images, targets_flat, target_lengths, input_lengths, paths = batch\n                images = images.to(device)\n                targets_flat = targets_flat.to(device)\n                target_lengths = target_lengths.to(device)\n                input_lengths = input_lengths.to(device)\n                \n                logits = model(images)\n                log_probs = logits.log_softmax(dim=-1)\n                loss = criterion(log_probs, targets_flat, input_lengths, target_lengths)\n                \n                total_val_loss += loss.item()\n                num_val_batches += 1\n        \n        avg_val_loss = total_val_loss / num_val_batches\n        \n        print(f\"Epoch {epoch+1}/{epochs} Summary:\")\n        print(f\"  Train Loss: {avg_train_loss:.4f}\")\n        print(f\"  Val Loss: {avg_val_loss:.4f}\")\n        metrics.add_epoch(epoch+1, avg_train_loss, avg_val_loss)\n        \n        # Enhanced early stopping check\n        val_train_ratio = avg_val_loss / (avg_train_loss + 1e-8)  # Avoid division by zero\n        \n        if avg_val_loss < best_val_loss:\n            best_val_loss = avg_val_loss\n            patience_counter = 0\n            print(f\"  New best validation loss: {best_val_loss:.4f}\")\n            print(f\"  Val/Train ratio: {val_train_ratio:.3f}\")\n            \n            # Save best model checkpoint with metadata\n            checkpoint = {\n                'epoch': epoch + 1,\n                'model_state_dict': model.state_dict(),\n                'optimizer_state_dict': optimizer.state_dict(),\n                'scheduler_state_dict': scheduler.state_dict(),\n                'best_val_loss': best_val_loss,\n                'train_loss': avg_train_loss,\n                'val_loss': avg_val_loss,\n                'val_train_ratio': val_train_ratio,\n                'config': {\n                    'vocab_size': vocab_size(),\n                    'hidden_size': 320,\n                    'total_stride': cfg.total_stride,\n                    'H': cfg.H,\n                    'W_max': cfg.W_max\n                }\n            }\n            torch.save(checkpoint, \"checkpoints/best_model.pth\")\n            print(f\"  Best model saved to checkpoints/best_model.pth\")\n            \n        else:\n            patience_counter += 1\n            print(f\"  No improvement for {patience_counter} epochs\")\n            print(f\"  Val/Train ratio: {val_train_ratio:.3f}\")\n            \n        # Enhanced early stopping: Check both absolute loss and ratio\n        if patience_counter >= patience or val_train_ratio > 3.0:  # Stop if ratio > 3x\n            if val_train_ratio > 3.0:\n                print(f\"  Early stopping triggered! Val/Train ratio too high: {val_train_ratio:.3f}\")\n            else:\n                print(f\" Early stopping triggered! No improvement for {patience} epochs\")\n            early_stop = True\n            break\n\n        # Test some predictions\n        if epoch % 2 == 0:  # Every 2 epochs\n            print(\"Sample predictions:\")\n            with torch.no_grad():\n                test_batch = next(iter(val_dl))\n                test_images = test_batch[0][:5].to(device)  # First 5 images\n                print(f\"    Input image shape: {test_images.shape}\")\n                print(f\"    Input image min/max: {test_images.min():.4f}/{test_images.max():.4f}\")\n                test_logits = model(test_images)\n                \n                # Debug: Check logits shape and values\n                print(f\"    Logits shape: {test_logits.shape}\")\n                print(f\"    Expected logits shape: [W//stride, B, V] = [{cfg.W_max}//{cfg.total_stride}, 5, 63] = [{cfg.W_max//cfg.total_stride}, 5, 63]\")\n                print(f\"    Logits min/max: {test_logits.min():.4f}/{test_logits.max():.4f}\")\n                \n                # Check raw predictions and blank probability (from softmax)\n                raw_preds = test_logits.argmax(dim=-1)\n                probs = test_logits.log_softmax(-1).exp()\n                avg_blank_prob = probs[..., 0].mean().item()\n                print(f\"    Raw predictions shape: {raw_preds.shape}\")\n                print(f\"    Raw predictions sample: {raw_preds[:10, 0].tolist()}\")\n                print(f\"    Avg blank prob (softmax): {avg_blank_prob:.4f}\")\n                print(f\"    Blank probability (argmax): {(raw_preds == 0).float().mean():.4f}\")\n                \n                test_preds = ctc_greedy_decode(test_logits)\n                \n                # Decode the target integers back to text strings with proper offsets\n                targets_flat, target_lengths = test_batch[1], test_batch[2]\n                offsets = torch.zeros(len(target_lengths), dtype=torch.long)\n                offsets[1:] = torch.cumsum(target_lengths[:-1], dim=0)\n                test_targets = []\n                for i in range(min(5, len(target_lengths))):\n                    s = offsets[i].item()\n                    e = s + target_lengths[i].item()\n                    indices = targets_flat[s:e].tolist()\n                    test_targets.append(decode_indices(indices))\n                \n                # Calculate CER for this batch\n                batch_cer = sum(cer(p, t) for p, t in zip(test_preds, test_targets)) / len(test_targets)\n                print(f\"    Val CER (approx): {batch_cer:.3f}\")\n                \n                for i, (pred, target) in enumerate(zip(test_preds, test_targets)):\n                    print(f\"    {i}: Predicted='{pred}', Target='{target}'\")\n                \n                metrics.add_predictions(test_preds, test_targets)\n\n    if early_stop:\n        print(f\"\\nTraining stopped early at epoch {epoch+1} due to no improvement!\")\n    else:\n        print(f\"\\nTraining completed for all {epochs} epochs!\")\n    \n    # Save final model\n    final_checkpoint = {\n        'epoch': epoch + 1,\n        'model_state_dict': model.state_dict(),\n        'optimizer_state_dict': optimizer.state_dict(),\n        'scheduler_state_dict': scheduler.state_dict(),\n        'final_val_loss': avg_val_loss,\n        'final_train_loss': avg_train_loss,\n        'config': {\n            'vocab_size': vocab_size(),\n            'hidden_size': 320,\n            'total_stride': cfg.total_stride,\n            'H': cfg.H,\n            'W_max': cfg.W_max\n        }\n    }\n    torch.save(final_checkpoint, \"checkpoints/final_model.pth\")\n    print(f\"Final model saved to checkpoints/final_model.pth\")\n    \n    print(\"\\nGenerating training metrics and plots...\")\n    os.makedirs(\"Metrics\", exist_ok=True)\n    metrics.plot_losses()\n    metrics.plot_loss_comparison()\n    metrics.save_metrics()\n    \n    # Final validation test\n    model.eval()\n    with torch.no_grad():\n        images, targets_flat, target_lengths, input_lengths, paths = next(iter(val_dl))\n        images = images.to(device)\n        logits = model(images)\n        preds = ctc_greedy_decode(logits)\n        \n        print(\"\\nFinal validation predictions:\")\n        for i, pred in enumerate(preds[:10]):\n            print(f\"  {i}: {pred}\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\train.py",
                    "filename": "train.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 18,
                    "end_line": 274,
                    "symbol": "main",
                    "chunk_idx": 2,
                    "size": 11157,
                    "_id": "dbf40dd7-cc46-5fee-98fa-69ef45e69d5d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 Completed Components\n- **Dataset Generation**: Synthetic CAPTCHA creation with train/val/test splits (8k train, 1k val)\n- **Configuration**: Centralized config with image dimensions and training parameters\n- **Vocabulary System**: Character encoding/decoding with CTC blank token support (63 classes)\n- **CTC Collate Function**: Proper batching for variable-length sequences\n- **CTC Decoding**: Greedy decode for inference\n- **PyTorch Dataset Class**: Image loading and preprocessing with proper cv2 resizing\n- **CRNN Model**: CNN encoder + BiLSTM + LayerNorm + linear output (working!)\n- **Training Loop**: Complete epoch-based training pipeline with validation\n- **Metrics & Plotting**: Training/validation loss tracking with beautiful visualizations\n- **Debugging Tools**: Comprehensive logging of logits, predictions, and model health  \n### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 3,
                    "size": 945,
                    "_id": "cc52b2b4-6738-5973-9c50-29fc8882ca66",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_stats():\n    total_rows = len_df()\n    print(f\"Starting evaluation on {total_rows} rows...\")\n    \n    y_true = []\n    y_pred = []\n    \n    # Iterate through the dataset\n    for idx in tqdm(range(total_rows)):\n        try:\n            result = predict.predict_attack_by_idx(idx)\n            \n            actual = result[\"target_class\"]\n            # Logic: If status is Attack Detected, use the LightGBM prediction. \n            # Otherwise, it's Benign (0).\n            if result[\"status\"] == \"Attack Detected\":\n                predicted = result.get(\"supervised\", {}).get(\"lightgbm\", 0)\n            else:\n                predicted = 0\n                \n            y_true.append(actual)\n            y_pred.append(predicted)\n        except Exception as e:\n            print(f\"Error at index {idx}: {e}\")\n            continue\n\n    # 1. Generate Text Report\n    report = classification_report(y_true, y_pred)\n    cm = confusion_matrix(y_true, y_pred)\n    \n    output_text = \"=== CONFUSION MATRIX ===\\n\"\n    output_text += str(cm) + \"\\n\\n\"\n    output_text += \"=== CLASSIFICATION REPORT ===\\n\"\n    output_text += report\n    \n    with open(\"confusion_matrix.txt\", \"w\") as f:\n        f.write(output_text)\n    \n    print(\"\\nText report saved to confusion_matrix.txt\")\n\n    # 2. Generate Heatmap Plot\n    plt.figure(figsize=(12, 10))\n    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n                xticklabels=np.unique(y_true), \n                yticklabels=np.unique(y_true))\n    plt.title(\"Intrusion Detection Confusion Matrix\\n(Hierarchical Pipeline with LGBM Veto)\")\n    plt.xlabel(\"Predicted Class\")\n    plt.ylabel(\"Actual Class\")\n    plt.savefig(\"confusion_matrix.png\", dpi=300)\n    plt.close()\n    \n    print(\"Plot saved to confusion_matrix.png\")\n\n    # 3. Generate Classification Report Heatmap\n    report_dict = classification_report(y_true, y_pred, output_dict=True)\n    # Convert to DataFrame and remove support/averages for plotting\n    report_df = pd.DataFrame(report_dict).iloc[:-1, :].T\n    report_df = report_df.drop(['accuracy', 'macro avg', 'weighted avg'], axis=0, errors='ignore')\n    \n    plt.figure(figsize=(10, 8))\n    sns.heatmap(report_df, annot=True, cmap='Blues')\n    plt.title(\"Classification Report Metrics per Class\")\n    plt.savefig(\"classification_report.png\", dpi=300)\n    plt.close()\n    \n    print(\"Plot saved to classification_report.png\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\stats.py",
                    "filename": "stats.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 14,
                    "end_line": 79,
                    "symbol": "generate_stats",
                    "chunk_idx": 1,
                    "size": 2387,
                    "_id": "efed5473-b5ea-53c4-bf8f-15863894d13a",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def initial_outreach(user,company,recruiter_name,title=\"HR Manager\"):\n    response = chat.send_message(\n        content=[\n            f\"\"\"\n            Generate a professional cold email to {recruiter_name}, with the title {title} at {company}, inquiring about internship opportunities for the (fill this according to my resume and company) position based on the resume details provided to you earlier.\n            Make sure it is custom tailored to me.\n\n            1.Start with a concise introduction about myself, including key skills and relevant experience.\n            2.Express genuine interest in the company and why I want to intern there.\n            3.Briefly mention a key project or achievement that aligns with the role.\n            4.End with a polite call to action, asking about internship openings or guidance on applying.\n            5.Keep the email professional, friendly, and under 200 words.\n            6.Make sure there are no placeholders in the text\n            You could include a small text in the end like : \"P.S Im mailing this through a automated internship applying bot made by me\" do it a bit creatively\n            Make sure you only return the mail body & subject nothing else.\n            \"\"\"\n        ]\n    )\n    \n    \n    str = response.text\n    str = str.split('\\n',1)\n    subject,body = str[0],str[1]\n    print(subject)\n    print(body)\n\n    return subject,body",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 126,
                    "end_line": 152,
                    "symbol": "initial_outreach",
                    "chunk_idx": 8,
                    "size": 1399,
                    "_id": "d86b54a9-1a4d-5066-9a7d-d30e8d47bae3",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def sampler(target_class):\n\n    sample_df = df.filter(pl.col(\"Attack\") == target_class).sample(1)\n    \n    if sample_df.height == 0:\n        raise ValueError(f\"No data found for class {target_class}\")\n    \n    idx = sample_df[\"original_index\"][0]\n    features = sample_df.drop([\"Attack\", \"original_index\"]).to_numpy()\n    \n    return features, idx",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\utils.py",
                    "filename": "utils.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 27,
                    "end_line": 37,
                    "symbol": "sampler",
                    "chunk_idx": 2,
                    "size": 347,
                    "_id": "54f49c6b-aa1a-56a9-aa35-f58729154a55",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "import os\nimport string\nfrom dataclasses import dataclass",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\config.py",
                    "filename": "config.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 3,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 57,
                    "_id": "b7799078-0cc3-5980-bb33-b84f53685efb",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Resume Loading**: The script reads the resume and stores its details in AI memory.\n2. **Recruiter Selection**: Fetches recruiters from the database who haven't been contacted.\n3. **Email Verification**: Ensures the email is valid before sending.\n4. **AI-Generated Email**: Gemini AI crafts a custom email based on the recruiter's details.\n5. **Automated Sending**: Uses Gmail API to send the email with an attached resume.\n6. **Logging & Tracking**: Updates the database to mark recruiters as contacted.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "How It Works",
                    "symbol": "How It Works",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "6dcf5e32-a80e-5849-aa46-ad41296904c3",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "import os\nimport base64\nfrom google.oauth2.credentials import Credentials\nfrom google_auth_oauthlib.flow import InstalledAppFlow\nfrom google.auth.transport.requests import Request\nfrom googleapiclient.discovery import build\nfrom email.mime.text import MIMEText\nfrom email.mime.multipart import MIMEMultipart\nfrom email.mime.base import MIMEBase\nfrom email import encoders\nimport time,random\nimport google.generativeai as genai\nimport pathlib\nimport os\nimport psycopg2\nimport pandas as pd\nimport smtplib\nAPI_KEY = \"YOUR_GEMINI_API_KEY\"\nSCOPES = [\"https://www.googleapis.com/auth/gmail.send\"]",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 22,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 590,
                    "_id": "c924aec1-3d7c-50ba-95a0-f9fc943c2685",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "google-auth-oauthlib\ngoogle-auth\ngoogle-auth-httplib2\ngoogle-api-python-client\npsycopg2\npandas\nsmtplib\nemail\nbase64\nrequests\ngoogle-generativeai\n",
                "metadata": {
                    "repo": "HermesGPT",
                    "path": "knowledge_base/repos/HermesGPT/requirements.txt",
                    "filename": "requirements.txt",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 145,
                    "_id": "e7295db8-34c6-55bf-a814-702ef9f1cf9a",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def _predict_lightgbm(raw_sample, scaled_data=None):\n    start_time = time.perf_counter()\n    if scaled_data is None:\n        scaled_data = scale_supervised(raw_sample)\n    y_pred = LIGHTGBM_MODEL.predict(scaled_data)\n    latency = time.perf_counter() - start_time\n    # Use .ravel()[0] to handle both scalars and arrays\n    return int(np.atleast_1d(y_pred).ravel()[0]), latency",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\predict.py",
                    "filename": "predict.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 109,
                    "end_line": 116,
                    "symbol": "_predict_lightgbm",
                    "chunk_idx": 7,
                    "size": 378,
                    "_id": "4ae4ce30-8954-5629-a809-32a326f77136",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Resume Loading**: The script reads the resume and stores its details in AI memory.\n2. **Recruiter Selection**: Fetches recruiters from the database who haven't been contacted.\n3. **Email Verification**: Ensures the email is valid before sending.\n4. **AI-Generated Email**: Gemini AI crafts a custom email based on the recruiter's details.\n5. **Automated Sending**: Uses Gmail API to send the email with an attached resume.\n6. **Logging & Tracking**: Updates the database to mark recruiters as contacted.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "How It Works",
                    "symbol": "How It Works",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "6dcf5e32-a80e-5849-aa46-ad41296904c3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "HermesGPT is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities. It integrates AI-generated personalized cold emails, database management, email verification, and automated sending using Gmail API.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "None",
                    "symbol": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "chunk_idx": 0,
                    "size": 271,
                    "_id": "8b6916d8-be29-5c9f-9c4a-5a0be949d971",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- [CTC Paper](https://www.cs.toronto.edu/~graves/icml_2006.pdf)\n- [CRNN Architecture](https://arxiv.org/abs/1507.05717)  \nThis project is for educational purposes. Feel free to use and modify as needed.  \n---  \n**Happy coding! \ud83d\ude80**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcda Resources",
                    "symbol": "\ud83d\udcda Resources",
                    "chunk_idx": 17,
                    "size": 230,
                    "_id": "9f806412-10e4-5a7b-be49-08175ab1d285",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Feel free to fork this project and submit pull requests! \ud83d\ude80",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Contributing",
                    "symbol": "Contributing",
                    "chunk_idx": 6,
                    "size": 58,
                    "_id": "4dcbff5d-f7d7-5fb5-aa1c-b81dd0b70acd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This is a learning project! Feel free to:\n- Ask questions about implementation details\n- Experiment with different architectures\n- Improve the data generation or training pipeline",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83e\udd1d Contributing",
                    "symbol": "\ud83e\udd1d Contributing",
                    "chunk_idx": 16,
                    "size": 179,
                    "_id": "0bb57d4e-10c5-5bbe-83d6-74f9591fda94",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "CAPTCHA OCR Training Metrics\n==================================================\n\nTraining completed at: 2025-08-20 02:25:00\nTotal epochs: 22\n\nLoss Summary:\n--------------------\nFinal training loss: 0.0146\nFinal validation loss: 0.0460\nBest training loss: 0.0146\nBest validation loss: 0.0460\nTraining loss improvement: 6.8262\nValidation loss improvement: 3.6347\n\nSample Predictions:\n--------------------\nSample 1: Predicted='N', Target='XjlCAhL'\nSample 2: Predicted='Mw', Target='I4Mwfs6'\nSample 3: Predicted='V', Target='CqHY4s'\nSample 4: Predicted='g', Target='dI3F6'\nSample 5: Predicted='HqU', Target='n0tfU'\nSample 6: Predicted='jxjlCAhL', Target='XjlCAhL'\nSample 7: Predicted='l4Mwfs6', Target='I4Mwfs6'\nSample 8: Predicted='CqHY4s', Target='CqHY4s'\nSample 9: Predicted='dI3F6', Target='dI3F6'\nSample 10: Predicted='n0tU', Target='n0tfU'\n",
                "metadata": {
                    "repo": "CaptchaOCR",
                    "path": "knowledge_base/repos/CaptchaOCR/Metrics/training_metrics.txt",
                    "filename": "training_metrics.txt",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 842,
                    "_id": "c58b990f-7efc-500a-84aa-496026e39763",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "with gr.Blocks(title=\"CAPTCHA OCR (checkpoint)\") as demo:\n    gr.Markdown(\"## CAPTCHA OCR \")\n\n    with gr.Row():\n        # Left column: Generate button + Solve button stacked vertically\n        with gr.Column(scale=1):\n            gen_btn = gr.Button(\"Generate CAPTCHA\", variant=\"primary\")\n            solve_btn = gr.Button(\"Solve\", interactive=False, variant=\"secondary\")\n        \n        # Right column: Ground Truth\n        gt_out = gr.Textbox(label=\"Ground Truth\", interactive=False, text_align=\"center\")\n\n    with gr.Row():\n        img_out = gr.Image(label=\"Generated CAPTCHA\", type=\"pil\")\n        path_box = gr.Textbox(label=\"Internal Path\", interactive=False, visible=False)\n\n    # Prediction row split into two columns\n    with gr.Row():\n        accuracy_out = gr.Textbox(label=\"Character Accuracy\", interactive=False, text_align=\"center\")\n        pred_out = gr.Textbox(label=\"Prediction\", interactive=False, text_align=\"center\")\n\n    # Generate: outputs image, ground truth, path, and enables Solve (green)\n    gen_btn.click(\n        fn=ui_generate,\n        outputs=[img_out, gt_out, path_box, solve_btn],\n    )\n\n    # Solve: only uses the internal path (no upload option anymore)\n    solve_btn.click(\n        fn=ui_solve,\n        inputs=[path_box, gt_out],\n        outputs=[accuracy_out, pred_out],\n    )\nif __name__ == \"__main__\":\n    demo.launch()",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\app.py",
                    "filename": "app.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 66,
                    "end_line": 101,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 1359,
                    "_id": "d33e2103-8a96-5c78-a5ce-4f9aff805aa9",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "The project follows a modular architecture designed for low-latency inference and high throughput.  \n```mermaid\ngraph TD\nA[Network Traffic / PCAP] -->|Feature Extraction| B(CICIDS Features)\nB --> C{Hybrid Pipeline}\nC --> D[Unsupervised Layer]\nD -->|Anomalies Flagged| E[Supervised Layer]\nE -->|Final Classification| F[Actionable Insight]\nD -->|Benign| G[Safe Traffic]\n```  \n### Machine Learning Pipeline\nThe core of this project is a **Hierarchical Detection Strategy**:  \n1.  **Unsupervised Layer (The Flaggers)**:\n- **Autoencoder**: Reconstructs input data; high reconstruction error indicates an anomaly.\n- **Isolation Forest**: Detects anomalies by isolating observations in feature space.\n- *Logic*: If either model flags the traffic, it proceeds to the next stage.  \n2.  **Supervised Layer (The Judges)**:\n- **LightGBM (Final Veto)**: A gradient boosting framework that provides the final classification.",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "System Architecture",
                    "symbol": "System Architecture",
                    "chunk_idx": 1,
                    "size": 910,
                    "_id": "755fce9d-1447-54ea-9959-5a3136e676ba",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- [CTC Paper](https://www.cs.toronto.edu/~graves/icml_2006.pdf)\n- [CRNN Architecture](https://arxiv.org/abs/1507.05717)  \nThis project is for educational purposes. Feel free to use and modify as needed.  \n---  \n**Happy coding! \ud83d\ude80**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcda Resources",
                    "symbol": "\ud83d\udcda Resources",
                    "chunk_idx": 17,
                    "size": 230,
                    "_id": "9f806412-10e4-5a7b-be49-08175ab1d285",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "with gr.Blocks(title=\"CAPTCHA OCR (checkpoint)\") as demo:\n    gr.Markdown(\"## CAPTCHA OCR \")\n\n    with gr.Row():\n        # Left column: Generate button + Solve button stacked vertically\n        with gr.Column(scale=1):\n            gen_btn = gr.Button(\"Generate CAPTCHA\", variant=\"primary\")\n            solve_btn = gr.Button(\"Solve\", interactive=False, variant=\"secondary\")\n        \n        # Right column: Ground Truth\n        gt_out = gr.Textbox(label=\"Ground Truth\", interactive=False, text_align=\"center\")\n\n    with gr.Row():\n        img_out = gr.Image(label=\"Generated CAPTCHA\", type=\"pil\")\n        path_box = gr.Textbox(label=\"Internal Path\", interactive=False, visible=False)\n\n    # Prediction row split into two columns\n    with gr.Row():\n        accuracy_out = gr.Textbox(label=\"Character Accuracy\", interactive=False, text_align=\"center\")\n        pred_out = gr.Textbox(label=\"Prediction\", interactive=False, text_align=\"center\")\n\n    # Generate: outputs image, ground truth, path, and enables Solve (green)\n    gen_btn.click(\n        fn=ui_generate,\n        outputs=[img_out, gt_out, path_box, solve_btn],\n    )\n\n    # Solve: only uses the internal path (no upload option anymore)\n    solve_btn.click(\n        fn=ui_solve,\n        inputs=[path_box, gt_out],\n        outputs=[accuracy_out, pred_out],\n    )\nif __name__ == \"__main__\":\n    demo.launch()",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\app.py",
                    "filename": "app.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 66,
                    "end_line": 101,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 1359,
                    "_id": "d33e2103-8a96-5c78-a5ce-4f9aff805aa9",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_test_captcha(text, filename, width=256, height=60):\n    \"\"\"Generate a test CAPTCHA image using enhanced generation.\"\"\"\n    # Use the enhanced CAPTCHA generation from generateCaptcha.py\n    img = generate_captcha(text, width=width, height=height)\n    \n    # Ensure results directory exists\n    os.makedirs(cfg.RESULT_DIR, exist_ok=True)\n    \n    filepath = os.path.join(cfg.RESULT_DIR, filename)\n    img.save(filepath)\n    print(f\"Generated enhanced test CAPTCHA: {filename}\")\n    return filepath",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 72,
                    "end_line": 83,
                    "symbol": "generate_test_captcha",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "02bb7bcc-c46c-5763-ac36-ecf2ea7cbcd3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None):\n    \"\"\"\n    Generate a single enhanced CAPTCHA image.\n    \n    Args:\n        text (str, optional): Text to render. If None, generates random text.\n        width (int): Image width\n        height (int): Image height\n        save_path (str, optional): Path to save the image. If None, returns PIL Image.\n    \n    Returns:\n        PIL Image if save_path is None, otherwise saves and returns the path\n    \"\"\"\n    # Generate random text if none provided\n    if text is None:\n        text = ''.join(random.choices(CHARS, k=random.randint(CAPTCHA_LEN_LOWER_LIMIT, CAPTCHA_LEN_UPPER_LIMIT)))\n    \n    # Randomize basic style\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    \n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # Use ImageCaptcha for base text rendering\n    from captcha.image import ImageCaptcha\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n    \n    # Draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # Apply enhancements\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # Perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # Add interference\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # Noise + blur + JPEG recompression\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # Optional low contrast\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    # Save or return\n    if save_path:\n        base.save(save_path)\n        return save_path\n    else:\n        return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 104,
                    "end_line": 170,
                    "symbol": "generate_captcha",
                    "chunk_idx": 7,
                    "size": 2362,
                    "_id": "5961a050-0f46-5993-aadb-d341153dadc1",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "```\nCaptchaDetect/\n\u251c\u2500\u2500 Dataset/                 # Full dataset (100k images) - for Colab training\n\u251c\u2500\u2500 Dataset_test/           # Test dataset (1k images) - for local development\n\u2502   \u2514\u2500\u2500 captchas/\n\u2502       \u251c\u2500\u2500 train/          # 80% of data\n\u2502       \u251c\u2500\u2500 val/            # 10% of data\n\u2502       \u2514\u2500\u2500 test/           # 10% of data\n\u251c\u2500\u2500 src/\n\u2502   \u251c\u2500\u2500 config.py           # Configuration and hyperparameters\n\u2502   \u251c\u2500\u2500 vocab.py            # Character vocabulary and CTC encoding/decoding\n\u2502   \u251c\u2500\u2500 data.py             # Dataset generation script\n\u2502   \u251c\u2500\u2500 collate.py          # CTC batching function\n\u2502   \u251c\u2500\u2500 captcha_dataset.py  # PyTorch Dataset class\n\u2502   \u251c\u2500\u2500 model_crnn.py       # CRNN model architecture\n\u2502   \u2514\u2500\u2500 plotting.py         # Training metrics and visualization\n\u251c\u2500\u2500 train.py                # Main training script (\u2705 WORKING!)\n\u251c\u2500\u2500 Metrics/                # Training plots and logs (auto-generated)\n\u251c\u2500\u2500 .gitignore              # Ignores dataset contents, keeps structure\n\u2514\u2500\u2500 README.md               # This file\n```",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcc1 Project Structure",
                    "symbol": "\ud83d\udcc1 Project Structure",
                    "chunk_idx": 6,
                    "size": 1000,
                    "_id": "c4ad4ab2-d4d1-52cc-ac79-15c6a80162c1",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Feel free to fork this project and submit pull requests! \ud83d\ude80",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Contributing",
                    "symbol": "Contributing",
                    "chunk_idx": 6,
                    "size": 58,
                    "_id": "4dcbff5d-f7d7-5fb5-aa1c-b81dd0b70acd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None):\n    \"\"\"\n    Generate a single enhanced CAPTCHA image.\n    \n    Args:\n        text (str, optional): Text to render. If None, generates random text.\n        width (int): Image width\n        height (int): Image height\n        save_path (str, optional): Path to save the image. If None, returns PIL Image.\n    \n    Returns:\n        PIL Image if save_path is None, otherwise saves and returns the path\n    \"\"\"\n    # Generate random text if none provided\n    if text is None:\n        text = ''.join(random.choices(CHARS, k=random.randint(CAPTCHA_LEN_LOWER_LIMIT, CAPTCHA_LEN_UPPER_LIMIT)))\n    \n    # Randomize basic style\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    \n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # Use ImageCaptcha for base text rendering\n    from captcha.image import ImageCaptcha\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n    \n    # Draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # Apply enhancements\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # Perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # Add interference\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # Noise + blur + JPEG recompression\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # Optional low contrast\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    # Save or return\n    if save_path:\n        base.save(save_path)\n        return save_path\n    else:\n        return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 104,
                    "end_line": 170,
                    "symbol": "generate_captcha",
                    "chunk_idx": 7,
                    "size": 2362,
                    "_id": "5961a050-0f46-5993-aadb-d341153dadc1",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def configure_cors(app: FastAPI) -> None:\n    \"\"\"\n    Configure CORS middleware for the FastAPI application.\n    \n    Allows requests from specified origins with credentials support.\n    \"\"\"\n    # Define allowed origins\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    # Add CORS middleware\n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600  # Cache preflight requests for 1 hour\n    )",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 5,
                    "end_line": 29,
                    "symbol": "configure_cors",
                    "chunk_idx": 1,
                    "size": 780,
                    "_id": "cdf88a69-08e6-5ddc-85da-893dcf5a25ce",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Framework**: FastAPI\n- **Data Engine**: Polars & Pandas\n- **ML/DL**: PyTorch, Scikit-Learn, LightGBM, XGBoost\n- **Deployment**: Docker, Uvicorn\n- **Utilities**: Joblib, NumPy, Matplotlib/Seaborn  \n---\nDeveloped by **Mohak Kapoor**",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Tech Stack",
                    "symbol": "Tech Stack",
                    "chunk_idx": 5,
                    "size": 234,
                    "_id": "8b922ee1-0b4a-551f-bbf5-e1dcbbbca9b8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "annotated-doc==0.0.4\nannotated-types==0.7.0\nanyio==4.12.0\nclick==8.3.1\ncontourpy==1.3.3\ncramjam==2.11.0\ncycler==0.12.1\ndotenv==0.9.9\nfastapi==0.124.4\nfastparquet==2024.11.0\nfilelock==3.20.0\nfonttools==4.62.1\nfsspec==2025.12.0\nh11==0.16.0\nidna==3.11\nJinja2==3.1.6\njoblib==1.5.2\nkiwisolver==1.5.0\nlightgbm==4.6.0\nMarkupSafe==2.1.5\nmatplotlib==3.10.9\nmpmath==1.3.0\nnetworkx==3.6.1\nnumpy==2.3.5\npackaging==25.0\npandas==2.3.3\npillow==12.0.0\npolars==1.40.1\npolars-runtime-32==1.40.1\npyarrow==22.0.0\npydantic==2.12.5\npydantic_core==2.41.5\npyparsing==3.3.2\npython-dateutil==2.9.0.post0\npython-dotenv==1.2.1\npytz==2025.2\nscikit-learn==1.8.0\nscipy==1.16.3\nseaborn==0.13.2\nsetuptools==70.2.0\nsix==1.17.0\nstarlette==0.50.0\nsympy==1.14.0\nthreadpoolctl==3.6.0\ntorch\ntorchaudio\ntorchvision\ntqdm==4.67.3\ntyping-inspection==0.4.2\ntyping_extensions==4.15.0\ntzdata==2025.2\nuvicorn==0.38.0\nwebsockets==16.0\nxgboost==3.2.0\n",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/requirements.txt",
                    "filename": "requirements.txt",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 902,
                    "_id": "1e3a1dd7-2519-5be7-a52a-7cb7e21a3b0c",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "### 1. Environment Setup\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```  \n### 2. Generate Training Dataset\n```bash\ncd src\npython data.py\n```\nThis creates 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with proper train/val/test splits.  \n### 3. Start Training\n```bash\npython train.py\n```\nThis starts the full training pipeline with automatic metrics generation.  \n### 4. Monitor Progress\nTraining will show:\n- Real-time loss and prediction samples\n- Automatic plot generation in `Metrics/` folder\n- Comprehensive training logs and summaries",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\ude80 Quick Start",
                    "symbol": "\ud83d\ude80 Quick Start",
                    "chunk_idx": 7,
                    "size": 721,
                    "_id": "3b357f42-2155-5453-a29c-795d0e1c9c09",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "\"\"\"\nSimple CAPTCHA Generation Utility\nGenerates individual CAPTCHA images using enhanced rendering\n\"\"\"\nimport random\nimport string\nfrom PIL import Image, ImageDraw, ImageFilter\nimport numpy as np\nimport cv2\nimport io\nIMG_WIDTH = 256\nIMG_HEIGHT = 60\nGRAYSCALE = True\nCHARS = string.ascii_letters + string.digits\nCAPTCHA_LEN_LOWER_LIMIT = 5\nCAPTCHA_LEN_UPPER_LIMIT = 7",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 19,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 366,
                    "_id": "09eca634-dc2d-51df-8d00-ffce645259c8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_test_captcha(text, filename, width=256, height=60):\n    \"\"\"Generate a test CAPTCHA image using enhanced generation.\"\"\"\n    # Use the enhanced CAPTCHA generation from generateCaptcha.py\n    img = generate_captcha(text, width=width, height=height)\n    \n    # Ensure results directory exists\n    os.makedirs(cfg.RESULT_DIR, exist_ok=True)\n    \n    filepath = os.path.join(cfg.RESULT_DIR, filename)\n    img.save(filepath)\n    print(f\"Generated enhanced test CAPTCHA: {filename}\")\n    return filepath",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 72,
                    "end_line": 83,
                    "symbol": "generate_test_captcha",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "02bb7bcc-c46c-5763-ac36-ecf2ea7cbcd3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None):\n    \"\"\"\n    Generate a single enhanced CAPTCHA image.\n    \n    Args:\n        text (str, optional): Text to render. If None, generates random text.\n        width (int): Image width\n        height (int): Image height\n        save_path (str, optional): Path to save the image. If None, returns PIL Image.\n    \n    Returns:\n        PIL Image if save_path is None, otherwise saves and returns the path\n    \"\"\"\n    # Generate random text if none provided\n    if text is None:\n        text = ''.join(random.choices(CHARS, k=random.randint(CAPTCHA_LEN_LOWER_LIMIT, CAPTCHA_LEN_UPPER_LIMIT)))\n    \n    # Randomize basic style\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    \n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # Use ImageCaptcha for base text rendering\n    from captcha.image import ImageCaptcha\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n    \n    # Draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # Apply enhancements\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # Perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # Add interference\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # Noise + blur + JPEG recompression\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # Optional low contrast\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    # Save or return\n    if save_path:\n        base.save(save_path)\n        return save_path\n    else:\n        return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 104,
                    "end_line": 170,
                    "symbol": "generate_captcha",
                    "chunk_idx": 7,
                    "size": 2362,
                    "_id": "5961a050-0f46-5993-aadb-d341153dadc1",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "---\ntitle: CaptchaOCR\nemoji: \ud83d\udd0d\ncolorFrom: green\ncolorTo: gray\nsdk: gradio\nsdk_version: 5.43.1\napp_file: app.py\npinned: false\nshort_description: CAPTCHA text recognition using CRNN neural networks\n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "None",
                    "h2": "None",
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 199,
                    "_id": "021bd30a-71be-5b13-aa68-ee4b5182c015",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def api_name():\n    return {\"api_name\": \"Intrusion Detection API\"}",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 40,
                    "end_line": 41,
                    "symbol": "api_name",
                    "chunk_idx": 5,
                    "size": 72,
                    "_id": "9bf1f6da-08a0-57e2-ad5a-6c00e473cfcc",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "A PyTorch-based CAPTCHA recognition system using synthetic data generation and CTC-based sequence modeling. Built with deep learning techniques, achieving high accuracy on complex text recognition tasks.",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "None",
                    "symbol": "CAPTCHA OCR Project",
                    "chunk_idx": 1,
                    "size": 203,
                    "_id": "89c221f0-2ced-5f9a-9c1d-e200c57f37f5",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Framework**: FastAPI\n- **Data Engine**: Polars & Pandas\n- **ML/DL**: PyTorch, Scikit-Learn, LightGBM, XGBoost\n- **Deployment**: Docker, Uvicorn\n- **Utilities**: Joblib, NumPy, Matplotlib/Seaborn  \n---\nDeveloped by **Mohak Kapoor**",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Tech Stack",
                    "symbol": "Tech Stack",
                    "chunk_idx": 5,
                    "size": 234,
                    "_id": "8b922ee1-0b4a-551f-bbf5-e1dcbbbca9b8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Environment Setup\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```  \n### 2. Generate Training Dataset\n```bash\ncd src\npython data.py\n```\nThis creates 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with proper train/val/test splits.  \n### 3. Start Training\n```bash\npython train.py\n```\nThis starts the full training pipeline with automatic metrics generation.  \n### 4. Monitor Progress\nTraining will show:\n- Real-time loss and prediction samples\n- Automatic plot generation in `Metrics/` folder\n- Comprehensive training logs and summaries",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\ude80 Quick Start",
                    "symbol": "\ud83d\ude80 Quick Start",
                    "chunk_idx": 7,
                    "size": 721,
                    "_id": "3b357f42-2155-5453-a29c-795d0e1c9c09",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def initial_outreach(user,company,recruiter_name,title=\"HR Manager\"):\n    response = chat.send_message(\n        content=[\n            f\"\"\"\n            Generate a professional cold email to {recruiter_name}, with the title {title} at {company}, inquiring about internship opportunities for the (fill this according to my resume and company) position based on the resume details provided to you earlier.\n            Make sure it is custom tailored to me.\n\n            1.Start with a concise introduction about myself, including key skills and relevant experience.\n            2.Express genuine interest in the company and why I want to intern there.\n            3.Briefly mention a key project or achievement that aligns with the role.\n            4.End with a polite call to action, asking about internship openings or guidance on applying.\n            5.Keep the email professional, friendly, and under 200 words.\n            6.Make sure there are no placeholders in the text\n            You could include a small text in the end like : \"P.S Im mailing this through a automated internship applying bot made by me\" do it a bit creatively\n            Make sure you only return the mail body & subject nothing else.\n            \"\"\"\n        ]\n    )\n    \n    \n    str = response.text\n    str = str.split('\\n',1)\n    subject,body = str[0],str[1]\n    print(subject)\n    print(body)\n\n    return subject,body",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 126,
                    "end_line": 152,
                    "symbol": "initial_outreach",
                    "chunk_idx": 8,
                    "size": 1399,
                    "_id": "d86b54a9-1a4d-5066-9a7d-d30e8d47bae3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- \ud83d\udcc4 **Resume Parsing**: Loads and processes resume data for personalized email generation.\n- \ud83e\udd16 **AI-Powered Emails**: Uses Gemini AI to generate tailored cold emails.\n- \ud83d\udcec **Automated Email Sending**: Sends emails via Gmail API with attachments.\n- \u2705 **Email Verification**: Uses SMTP and Maileroo API to validate emails before sending.\n- \ud83d\uddc4 **Database Management**: Stores recruiter data in PostgreSQL and tracks outreach progress.\n- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Features",
                    "symbol": "Features",
                    "chunk_idx": 1,
                    "size": 529,
                    "_id": "2b1ec077-3dbf-5a35-8275-b58b0b6597fd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "HermesGPT is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities. It integrates AI-generated personalized cold emails, database management, email verification, and automated sending using Gmail API.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "None",
                    "symbol": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "chunk_idx": 0,
                    "size": 271,
                    "_id": "8b6916d8-be29-5c9f-9c4a-5a0be949d971",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Feel free to fork this project and submit pull requests! \ud83d\ude80",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Contributing",
                    "symbol": "Contributing",
                    "chunk_idx": 6,
                    "size": 58,
                    "_id": "4dcbff5d-f7d7-5fb5-aa1c-b81dd0b70acd",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "[![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=for-the-badge&logo=fastapi)](https://fastapi.tiangolo.com)\n[![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)\n[![PyTorch](https://img.shields.io/badge/PyTorch-EE4C2C?style=for-the-badge&logo=pytorch&logoColor=white)](https://pytorch.org/)\n[![Docker](https://img.shields.io/badge/Docker-2496ED?style=for-the-badge&logo=docker&logoColor=white)](https://www.docker.com/)  \nAn enterprise-grade **Network Intrusion Detection System (NIDS)** backend powered by a state-of-the-art hierarchical machine learning pipeline. This system doesn't just predict; it verifies anomalies through a multi-layered \"Veto\" logic to ensure maximum accuracy and minimum false alarms.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend",
                    "chunk_idx": 0,
                    "size": 805,
                    "_id": "7eef7577-628b-5a31-b8c1-60aa64a23e9f",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi.middleware.cors import CORSMiddleware\nfrom fastapi import FastAPI",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 2,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 78,
                    "_id": "afba59f5-c68c-50fb-98b3-e3c232782271",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Framework**: FastAPI\n- **Data Engine**: Polars & Pandas\n- **ML/DL**: PyTorch, Scikit-Learn, LightGBM, XGBoost\n- **Deployment**: Docker, Uvicorn\n- **Utilities**: Joblib, NumPy, Matplotlib/Seaborn  \n---\nDeveloped by **Mohak Kapoor**",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Tech Stack",
                    "symbol": "Tech Stack",
                    "chunk_idx": 5,
                    "size": 234,
                    "_id": "8b922ee1-0b4a-551f-bbf5-e1dcbbbca9b8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def configure_cors(app: FastAPI) -> None:\n    \"\"\"\n    Configure CORS middleware for the FastAPI application.\n    \n    Allows requests from specified origins with credentials support.\n    \"\"\"\n    # Define allowed origins\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    # Add CORS middleware\n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600  # Cache preflight requests for 1 hour\n    )",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 5,
                    "end_line": 29,
                    "symbol": "configure_cors",
                    "chunk_idx": 1,
                    "size": 780,
                    "_id": "cdf88a69-08e6-5ddc-85da-893dcf5a25ce",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "CAPTCHA OCR Training Metrics\n==================================================\n\nTraining completed at: 2025-08-20 02:25:00\nTotal epochs: 22\n\nLoss Summary:\n--------------------\nFinal training loss: 0.0146\nFinal validation loss: 0.0460\nBest training loss: 0.0146\nBest validation loss: 0.0460\nTraining loss improvement: 6.8262\nValidation loss improvement: 3.6347\n\nSample Predictions:\n--------------------\nSample 1: Predicted='N', Target='XjlCAhL'\nSample 2: Predicted='Mw', Target='I4Mwfs6'\nSample 3: Predicted='V', Target='CqHY4s'\nSample 4: Predicted='g', Target='dI3F6'\nSample 5: Predicted='HqU', Target='n0tfU'\nSample 6: Predicted='jxjlCAhL', Target='XjlCAhL'\nSample 7: Predicted='l4Mwfs6', Target='I4Mwfs6'\nSample 8: Predicted='CqHY4s', Target='CqHY4s'\nSample 9: Predicted='dI3F6', Target='dI3F6'\nSample 10: Predicted='n0tU', Target='n0tfU'\n",
                "metadata": {
                    "repo": "CaptchaOCR",
                    "path": "knowledge_base/repos/CaptchaOCR/Metrics/training_metrics.txt",
                    "filename": "training_metrics.txt",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 842,
                    "_id": "c58b990f-7efc-500a-84aa-496026e39763",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "with gr.Blocks(title=\"CAPTCHA OCR (checkpoint)\") as demo:\n    gr.Markdown(\"## CAPTCHA OCR \")\n\n    with gr.Row():\n        # Left column: Generate button + Solve button stacked vertically\n        with gr.Column(scale=1):\n            gen_btn = gr.Button(\"Generate CAPTCHA\", variant=\"primary\")\n            solve_btn = gr.Button(\"Solve\", interactive=False, variant=\"secondary\")\n        \n        # Right column: Ground Truth\n        gt_out = gr.Textbox(label=\"Ground Truth\", interactive=False, text_align=\"center\")\n\n    with gr.Row():\n        img_out = gr.Image(label=\"Generated CAPTCHA\", type=\"pil\")\n        path_box = gr.Textbox(label=\"Internal Path\", interactive=False, visible=False)\n\n    # Prediction row split into two columns\n    with gr.Row():\n        accuracy_out = gr.Textbox(label=\"Character Accuracy\", interactive=False, text_align=\"center\")\n        pred_out = gr.Textbox(label=\"Prediction\", interactive=False, text_align=\"center\")\n\n    # Generate: outputs image, ground truth, path, and enables Solve (green)\n    gen_btn.click(\n        fn=ui_generate,\n        outputs=[img_out, gt_out, path_box, solve_btn],\n    )\n\n    # Solve: only uses the internal path (no upload option anymore)\n    solve_btn.click(\n        fn=ui_solve,\n        inputs=[path_box, gt_out],\n        outputs=[accuracy_out, pred_out],\n    )\nif __name__ == \"__main__\":\n    demo.launch()",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\app.py",
                    "filename": "app.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 66,
                    "end_line": 101,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 1359,
                    "_id": "d33e2103-8a96-5c78-a5ce-4f9aff805aa9",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- [CTC Paper](https://www.cs.toronto.edu/~graves/icml_2006.pdf)\n- [CRNN Architecture](https://arxiv.org/abs/1507.05717)  \nThis project is for educational purposes. Feel free to use and modify as needed.  \n---  \n**Happy coding! \ud83d\ude80**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcda Resources",
                    "symbol": "\ud83d\udcda Resources",
                    "chunk_idx": 17,
                    "size": 230,
                    "_id": "9f806412-10e4-5a7b-be49-08175ab1d285",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def configure_cors(app: FastAPI) -> None:\n    \"\"\"\n    Configure CORS middleware for the FastAPI application.\n    \n    Allows requests from specified origins with credentials support.\n    \"\"\"\n    # Define allowed origins\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    # Add CORS middleware\n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600  # Cache preflight requests for 1 hour\n    )",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 5,
                    "end_line": 29,
                    "symbol": "configure_cors",
                    "chunk_idx": 1,
                    "size": 780,
                    "_id": "cdf88a69-08e6-5ddc-85da-893dcf5a25ce",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Framework**: FastAPI\n- **Data Engine**: Polars & Pandas\n- **ML/DL**: PyTorch, Scikit-Learn, LightGBM, XGBoost\n- **Deployment**: Docker, Uvicorn\n- **Utilities**: Joblib, NumPy, Matplotlib/Seaborn  \n---\nDeveloped by **Mohak Kapoor**",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Tech Stack",
                    "symbol": "Tech Stack",
                    "chunk_idx": 5,
                    "size": 234,
                    "_id": "8b922ee1-0b4a-551f-bbf5-e1dcbbbca9b8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi.middleware.cors import CORSMiddleware\nfrom fastapi import FastAPI",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 2,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 78,
                    "_id": "afba59f5-c68c-50fb-98b3-e3c232782271",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "HermesGPT is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities. It integrates AI-generated personalized cold emails, database management, email verification, and automated sending using Gmail API.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "None",
                    "symbol": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "chunk_idx": 0,
                    "size": 271,
                    "_id": "8b6916d8-be29-5c9f-9c4a-5a0be949d971",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- \ud83d\udcc4 **Resume Parsing**: Loads and processes resume data for personalized email generation.\n- \ud83e\udd16 **AI-Powered Emails**: Uses Gemini AI to generate tailored cold emails.\n- \ud83d\udcec **Automated Email Sending**: Sends emails via Gmail API with attachments.\n- \u2705 **Email Verification**: Uses SMTP and Maileroo API to validate emails before sending.\n- \ud83d\uddc4 **Database Management**: Stores recruiter data in PostgreSQL and tracks outreach progress.\n- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Features",
                    "symbol": "Features",
                    "chunk_idx": 1,
                    "size": 529,
                    "_id": "2b1ec077-3dbf-5a35-8275-b58b0b6597fd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Clone the Repository  \n```sh\ngit clone https://github.com/your-username/HermesGPT.git\ncd HermesGPT\n```  \n### 2. Install Dependencies  \nMake sure you have Python installed, then install the required packages:  \n```sh\npip install -r requirements.txt\n```  \n### 3. Configure Database  \nSet up a PostgreSQL database with the following schema:  \n```sql\nCREATE TABLE recruiters (\nemail TEXT PRIMARY KEY,\nrecruiter_name TEXT,\ncompany_name TEXT,\nrole TEXT,\ncontacted BOOLEAN DEFAULT FALSE\n);\n```  \n### 4. Set Up Gmail API  \n1. Enable the Gmail API from Google Cloud Console.\n2. Download `credentials.json` and place it in the project directory.\n3. Run authentication:  \n```sh\npython main.py\n```  \n### 5. API Keys  \n- **Gemini AI API**: Add your Gemini API key to the `API_KEY` variable.  \n### 6. Load Recruiter Data  \nPrepare a CSV file (`recruiters.csv`) with the following columns:  \n| Email | Name | Company | Title |\n|-------|------|---------|-------|",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Setup Instructions",
                    "symbol": "Setup Instructions",
                    "chunk_idx": 2,
                    "size": 953,
                    "_id": "c1147930-c01b-59e0-a7d4-b6330fbf4ec4",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Resume Loading**: The script reads the resume and stores its details in AI memory.\n2. **Recruiter Selection**: Fetches recruiters from the database who haven't been contacted.\n3. **Email Verification**: Ensures the email is valid before sending.\n4. **AI-Generated Email**: Gemini AI crafts a custom email based on the recruiter's details.\n5. **Automated Sending**: Uses Gmail API to send the email with an attached resume.\n6. **Logging & Tracking**: Updates the database to mark recruiters as contacted.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "How It Works",
                    "symbol": "How It Works",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "6dcf5e32-a80e-5849-aa46-ad41296904c3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def initial_outreach(user,company,recruiter_name,title=\"HR Manager\"):\n    response = chat.send_message(\n        content=[\n            f\"\"\"\n            Generate a professional cold email to {recruiter_name}, with the title {title} at {company}, inquiring about internship opportunities for the (fill this according to my resume and company) position based on the resume details provided to you earlier.\n            Make sure it is custom tailored to me.\n\n            1.Start with a concise introduction about myself, including key skills and relevant experience.\n            2.Express genuine interest in the company and why I want to intern there.\n            3.Briefly mention a key project or achievement that aligns with the role.\n            4.End with a polite call to action, asking about internship openings or guidance on applying.\n            5.Keep the email professional, friendly, and under 200 words.\n            6.Make sure there are no placeholders in the text\n            You could include a small text in the end like : \"P.S Im mailing this through a automated internship applying bot made by me\" do it a bit creatively\n            Make sure you only return the mail body & subject nothing else.\n            \"\"\"\n        ]\n    )\n    \n    \n    str = response.text\n    str = str.split('\\n',1)\n    subject,body = str[0],str[1]\n    print(subject)\n    print(body)\n\n    return subject,body",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 126,
                    "end_line": 152,
                    "symbol": "initial_outreach",
                    "chunk_idx": 8,
                    "size": 1399,
                    "_id": "d86b54a9-1a4d-5066-9a7d-d30e8d47bae3",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "async def websocket_stream(websocket: WebSocket):\n    await websocket.accept()\n    try:\n        # Expected JSON: {\"command\": \"start\", \"start_at\": 0}\n        initial_data = await websocket.receive_json()\n        \n        if initial_data.get(\"command\") == \"start\":\n            # Token Check\n            if initial_data.get(\"token\") != API_TOKEN:\n                await websocket.send_json({\"error\": \"Unauthorized\"})\n                await websocket.close(code=1008)\n                return\n            \n            await websocket.send_json({\"status\": \"Authentication Successful\", \"message\": \"Stream starting...\"})\n                \n            start_idx = initial_data.get(\"start_at\", 0)\n            batch_size = 100\n            total_rows = len_df()\n            \n            # Statistics tracking\n            stats = {\n                \"total_processed\": 0,\n                \"correct_predictions\": 0,\n                \"actual_counts\": {},\n                \"predicted_counts\": {},\n                \"total_latencies\": {\n                    \"autoencoder\": 0.0,\n                    \"isolation_forest\": 0.0,\n                    \"ffnn\": 0.0,\n                    \"lightgbm\": 0.0,\n                    \"logreg\": 0.0,\n                    \"xgboost\": 0.0,\n                    \"pipeline\": 0.0\n                },\n                \"latency_counts\": {\n                    \"autoencoder\": 0,\n                    \"isolation_forest\": 0,\n                    \"ffnn\": 0,\n                    \"lightgbm\": 0,\n                    \"logreg\": 0,\n                    \"xgboost\": 0,\n                    \"pipeline\": 0\n                }\n            }\n            \n            for i in range(start_idx, total_rows, batch_size):\n                batch_results = []\n                end_idx = min(i + batch_size, total_rows)\n\n                loop = asyncio.get_event_loop()\n                for idx in range(i, end_idx):\n                    result = await loop.run_in_executor(None,predict.predict_attack_by_idx,idx)\n                    batch_results.append(result)\n                    \n                    # Update Statistics\n                    actual = str(result[\"target_class\"])\n                    # Use LightGBM prediction for accuracy tracking\n                    predicted = str(result.get(\"supervised\", {}).get(\"lightgbm\", 0)) if result[\"status\"] == \"Attack Detected\" else \"0\"\n                    \n                    stats[\"total_processed\"] += 1\n                    if actual == predicted:\n                        stats[\"correct_predictions\"] += 1\n                    \n                    stats[\"actual_counts\"][actual] = stats[\"actual_counts\"].get(actual, 0) + 1\n                    stats[\"predicted_counts\"][predicted] = stats[\"predicted_counts\"].get(predicted, 0) + 1\n\n                    # Update Latencies\n                    res_lats = result.get(\"latencies\", {})\n                    for model, lat in res_lats.items():\n                        if model in stats[\"total_latencies\"]:\n                            stats[\"total_latencies\"][model] += lat\n                            stats[\"latency_counts\"][model] += 1\n                    \n                    stats[\"total_latencies\"][\"pipeline\"] += result.get(\"total_detection_time\", 0)\n                    stats[\"latency_counts\"][\"pipeline\"] += 1\n                \n                # Calculate current accuracy for this snapshot\n                current_acc = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n                \n                # Send the batch with real-time stats\n                await websocket.send_json({\n                    \"type\": \"batch\",\n                    \"batch_start\": i,\n                    \"batch_end\": end_idx,\n                    \"data\": batch_results,\n                    \"current_statistics\": {\n                        \"accuracy\": round(current_acc, 4),\n                        \"total_processed\": stats[\"total_processed\"],\n                        \"correct_predictions\": stats[\"correct_predictions\"]\n                    }\n                })\n                \n                await asyncio.sleep(0.01)\n            \n            # Send Final Statistics\n            accuracy = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n            \n            # Calculate Average Latencies\n            avg_latencies = {\n                model: round(stats[\"total_latencies\"][model] / stats[\"latency_counts\"][model], 6)\n                if stats[\"latency_counts\"][model] > 0 else 0\n                for model in stats[\"total_latencies\"]\n            }\n\n            await websocket.send_json({\n                \"type\": \"summary\",\n                \"status\": \"Stream Complete\",\n                \"statistics\": {\n                    \"accuracy\": round(accuracy, 4),\n                    \"total_processed\": stats[\"total_processed\"],\n                    \"correct_predictions\": stats[\"correct_predictions\"],\n                    \"actual_counts\": stats[\"actual_counts\"],\n                    \"predicted_counts\": stats[\"predicted_counts\"],\n                    \"average_latencies\": avg_latencies\n                }\n            })\n            \n            # Close connection after finishing the task\n            await websocket.close(code=1000)\n                \n    except WebSocketDisconnect:\n        print(f\"WebSocket client disconnected.\")\n    except Exception as e:\n        print(f\"WebSocket error: {str(e)}\")\n        await websocket.close(code=1011)",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 191,
                    "end_line": 315,
                    "symbol": "websocket_stream",
                    "chunk_idx": 15,
                    "size": 5449,
                    "_id": "4d64eb89-57c0-5ee0-91e1-1073db67be4d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Hierarchical ML Pipeline**: Combines Unsupervised Anomaly Detection (Autoencoders, Isolation Forests) with Supervised Classification (LightGBM, XGBoost, FFNN).\n- **Real-time Inference**: Optimized for low-latency network flow analysis.\n- **WebSocket Streaming**: Stream and evaluate massive datasets with live accuracy telemetry.\n- **Secure by Design**: Token-based authentication and restricted CORS policies.\n- **Containerized**: Ready for deployment via Docker and Docker Compose.\n- **Detailed Analytics**: Built-in tools for generating confusion matrices and classification reports.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Key Features",
                    "symbol": "Key Features",
                    "chunk_idx": 2,
                    "size": 596,
                    "_id": "2f101085-ba79-5828-8cac-b2324f51d4c6",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`\n- `POST /predict/autoencoder`\n- `POST /predict/isolationForest`\n- `POST /predict/xgboost`  \n---  \n### WebSocket Streaming\n`WS /intrusiondetection/ws/stream`\nStreams the dataset in batches of 100 rows with real-time statistics.  \n**Initialization Message**:\nAfter connecting, send the following JSON:\n```json\n{\n\"command\": \"start\",\n\"token\": \"your_secure_token_here\",\n\"start_at\": 0\n}\n```  \n**Final Summary Message**:\nAt the end of the stream, the server sends a summary containing final statistics and average latencies:\n```json\n{\n\"type\": \"summary\",\n\"status\": \"Stream Complete\",\n\"statistics\": {\n\"accuracy\": 0.85,\n\"total_processed\": 1000,\n\"correct_predictions\": 850,\n\"actual_counts\": {\"0\": 100, \"1\": 750, ...},\n\"predicted_counts\": {\"0\": 120, \"1\": 730, ...},\n\"average_latencies\": {\n\"autoencoder\": 0.000123,\n\"isolation_forest\": 0.000045,\n\"ffnn\": 0.000456,\n\"lightgbm\": 0.000789,\n\"logreg\": 0.000012,\n\"xgboost\": 0.000890,",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 5,
                    "size": 987,
                    "_id": "28326c1c-8329-5ba1-adda-3be25637f266",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "### 1. Environment Setup\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```  \n### 2. Generate Training Dataset\n```bash\ncd src\npython data.py\n```\nThis creates 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with proper train/val/test splits.  \n### 3. Start Training\n```bash\npython train.py\n```\nThis starts the full training pipeline with automatic metrics generation.  \n### 4. Monitor Progress\nTraining will show:\n- Real-time loss and prediction samples\n- Automatic plot generation in `Metrics/` folder\n- Comprehensive training logs and summaries",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\ude80 Quick Start",
                    "symbol": "\ud83d\ude80 Quick Start",
                    "chunk_idx": 7,
                    "size": 721,
                    "_id": "3b357f42-2155-5453-a29c-795d0e1c9c09",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 Completed Components\n- **Dataset Generation**: Synthetic CAPTCHA creation with train/val/test splits (8k train, 1k val)\n- **Configuration**: Centralized config with image dimensions and training parameters\n- **Vocabulary System**: Character encoding/decoding with CTC blank token support (63 classes)\n- **CTC Collate Function**: Proper batching for variable-length sequences\n- **CTC Decoding**: Greedy decode for inference\n- **PyTorch Dataset Class**: Image loading and preprocessing with proper cv2 resizing\n- **CRNN Model**: CNN encoder + BiLSTM + LayerNorm + linear output (working!)\n- **Training Loop**: Complete epoch-based training pipeline with validation\n- **Metrics & Plotting**: Training/validation loss tracking with beautiful visualizations\n- **Debugging Tools**: Comprehensive logging of logits, predictions, and model health  \n### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 3,
                    "size": 945,
                    "_id": "cc52b2b4-6738-5973-9c50-29fc8882ca66",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "[![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=for-the-badge&logo=fastapi)](https://fastapi.tiangolo.com)\n[![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)\n[![PyTorch](https://img.shields.io/badge/PyTorch-EE4C2C?style=for-the-badge&logo=pytorch&logoColor=white)](https://pytorch.org/)\n[![Docker](https://img.shields.io/badge/Docker-2496ED?style=for-the-badge&logo=docker&logoColor=white)](https://www.docker.com/)  \nAn enterprise-grade **Network Intrusion Detection System (NIDS)** backend powered by a state-of-the-art hierarchical machine learning pipeline. This system doesn't just predict; it verifies anomalies through a multi-layered \"Veto\" logic to ensure maximum accuracy and minimum false alarms.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend",
                    "chunk_idx": 0,
                    "size": 805,
                    "_id": "7eef7577-628b-5a31-b8c1-60aa64a23e9f",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence\n- **Model Architecture**: CRNN produces correct output shapes (64\u00d7batch\u00d763) with H=60, W=256\n- **Data Loading**: Proper image preprocessing and CTC batching\n- **Full CAPTCHA Recognition**: Model now recognizes complete CAPTCHA sequences\n- **Inference Pipeline**: Complete inference script with visualization and accuracy metrics\n- **Early Stopping**: Enhanced early stopping prevents overfitting automatically\n- **High Accuracy**: 75-100% overall accuracy, 25/26+ character accuracy (96%+)  \n### \ud83c\udfaf Training Status\n- **Current**: Epoch 8, excellent convergence achieved\n- **Best Model**: Validation loss 0.1782, early stopping working perfectly\n- **Performance**: 75-100% accuracy on fresh CAPTCHAs (varies by run)  \n### \ud83d\udcca Training Results\n![Training Losses](Metrics/training_losses.png)\n![Loss Comparison](Metrics/loss_comparison.png)  \n**Key Insights:**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 4,
                    "size": 953,
                    "_id": "594be5fe-581c-57f0-b467-0938c58aa712",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "```\nCaptchaDetect/\n\u251c\u2500\u2500 Dataset/                 # Full dataset (100k images) - for Colab training\n\u251c\u2500\u2500 Dataset_test/           # Test dataset (1k images) - for local development\n\u2502   \u2514\u2500\u2500 captchas/\n\u2502       \u251c\u2500\u2500 train/          # 80% of data\n\u2502       \u251c\u2500\u2500 val/            # 10% of data\n\u2502       \u2514\u2500\u2500 test/           # 10% of data\n\u251c\u2500\u2500 src/\n\u2502   \u251c\u2500\u2500 config.py           # Configuration and hyperparameters\n\u2502   \u251c\u2500\u2500 vocab.py            # Character vocabulary and CTC encoding/decoding\n\u2502   \u251c\u2500\u2500 data.py             # Dataset generation script\n\u2502   \u251c\u2500\u2500 collate.py          # CTC batching function\n\u2502   \u251c\u2500\u2500 captcha_dataset.py  # PyTorch Dataset class\n\u2502   \u251c\u2500\u2500 model_crnn.py       # CRNN model architecture\n\u2502   \u2514\u2500\u2500 plotting.py         # Training metrics and visualization\n\u251c\u2500\u2500 train.py                # Main training script (\u2705 WORKING!)\n\u251c\u2500\u2500 Metrics/                # Training plots and logs (auto-generated)\n\u251c\u2500\u2500 .gitignore              # Ignores dataset contents, keeps structure\n\u2514\u2500\u2500 README.md               # This file\n```",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcc1 Project Structure",
                    "symbol": "\ud83d\udcc1 Project Structure",
                    "chunk_idx": 6,
                    "size": 1000,
                    "_id": "c4ad4ab2-d4d1-52cc-ac79-15c6a80162c1",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def configure_cors(app: FastAPI) -> None:\n    \"\"\"\n    Configure CORS middleware for the FastAPI application.\n    \n    Allows requests from specified origins with credentials support.\n    \"\"\"\n    # Define allowed origins\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    # Add CORS middleware\n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600  # Cache preflight requests for 1 hour\n    )",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 5,
                    "end_line": 29,
                    "symbol": "configure_cors",
                    "chunk_idx": 1,
                    "size": 780,
                    "_id": "cdf88a69-08e6-5ddc-85da-893dcf5a25ce",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def configure_cors(app: FastAPI) -> None:\n    \"\"\"\n    Configure CORS middleware for the FastAPI application.\n    \n    Allows requests from specified origins with credentials support.\n    \"\"\"\n    # Define allowed origins\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    # Add CORS middleware\n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600  # Cache preflight requests for 1 hour\n    )",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 5,
                    "end_line": 29,
                    "symbol": "configure_cors",
                    "chunk_idx": 1,
                    "size": 780,
                    "_id": "cdf88a69-08e6-5ddc-85da-893dcf5a25ce",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi.middleware.cors import CORSMiddleware\nfrom fastapi import FastAPI",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 2,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 78,
                    "_id": "afba59f5-c68c-50fb-98b3-e3c232782271",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Authentication**: All sensitive endpoints are protected via `HTTPBearer` tokens.\n- **CORS**: Restricted to specific domains defined in `cors.py`.",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Security",
                    "symbol": "Security",
                    "chunk_idx": 10,
                    "size": 149,
                    "_id": "e9121e94-56a8-57b2-b4da-fc4b8b9b7252",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Environment Variables\nCreate a `.env` file with the following keys:\n```env\nTOKEN=your_secure_token\nPATH_LIGHTGBM=models/multiclass_lightgbm.joblib\nPATH_XGBOOST=models/multiclass_xgboost.joblib\nPATH_PCA=scalers/incrementail_pca_model.joblib\nPATH_STANDARD=scalers/standardscaler.joblib\nPATH_MINMAX=scalers/minmaxscaler.joblib\n```  \n### Running Locally\n```bash\n# Install dependencies\npip install -r requirements.txt\n\n# Start the server\npython router.py\n```  \n### Running with Docker\n```bash\ndocker-compose up --build\n```  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Setup & Installation",
                    "symbol": "Setup & Installation",
                    "chunk_idx": 8,
                    "size": 527,
                    "_id": "fe04ff55-2183-5d01-a6ef-e3b244311607",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Environment Setup\nClone the repository and create your `.env` file:\n```bash\ncp .env.example .env # Ensure you fill in your secure TOKEN\n```  \n### 2. Run with Docker (Recommended)\n```bash\ndocker-compose up --build\n```  \n### 3. Access the API\nThe API will be available at `http://localhost:8000`.\nCheck health: `GET /intrusiondetection/health`  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Quick Start",
                    "symbol": "Quick Start",
                    "chunk_idx": 3,
                    "size": 354,
                    "_id": "771b6b4f-d22a-5c00-bf87-906d2214f9bf",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "### 1. Environment Setup\nClone the repository and create your `.env` file:\n```bash\ncp .env.example .env # Ensure you fill in your secure TOKEN\n```  \n### 2. Run with Docker (Recommended)\n```bash\ndocker-compose up --build\n```  \n### 3. Access the API\nThe API will be available at `http://localhost:8000`.\nCheck health: `GET /intrusiondetection/health`  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Quick Start",
                    "symbol": "Quick Start",
                    "chunk_idx": 3,
                    "size": 354,
                    "_id": "771b6b4f-d22a-5c00-bf87-906d2214f9bf",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "version: '3.8'\n\nservices:\n  intrusion-tracker:\n    build: .\n    container_name: intrusion-api\n    ports:\n      - \"8000:8000\"\n    restart: always\n    env_file:\n      - .env",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/docker-compose.yml",
                    "filename": "docker-compose.yml",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 171,
                    "_id": "c720f8f0-b5a3-547f-87ba-2ae3bc79b573",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Hierarchical ML Pipeline**: Combines Unsupervised Anomaly Detection (Autoencoders, Isolation Forests) with Supervised Classification (LightGBM, XGBoost, FFNN).\n- **Real-time Inference**: Optimized for low-latency network flow analysis.\n- **WebSocket Streaming**: Stream and evaluate massive datasets with live accuracy telemetry.\n- **Secure by Design**: Token-based authentication and restricted CORS policies.\n- **Containerized**: Ready for deployment via Docker and Docker Compose.\n- **Detailed Analytics**: Built-in tools for generating confusion matrices and classification reports.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Key Features",
                    "symbol": "Key Features",
                    "chunk_idx": 2,
                    "size": 596,
                    "_id": "2f101085-ba79-5828-8cac-b2324f51d4c6",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def model_loading(resume_path):\n    resume_details = load_resume(resume_path)\n    if resume_path != None:\n        prompt = \"Load this resume in your memory. I will later ask you to generate me cold emails based on the details I will provide you Later. Also this is the link to my github = https://github.com/mohakapoor . Go through it as well and no need to add the link to the body.\"\n        response = chat.send_message(\n            content=[\n                {\"mime_type\": \"application/pdf\", \"data\": resume_details},\n                prompt\n            ]\n        )\n        print(response.text)\n    else:\n        print(\"Couldn't load the model\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 112,
                    "end_line": 124,
                    "symbol": "model_loading",
                    "chunk_idx": 7,
                    "size": 645,
                    "_id": "6a82e257-7d5c-50b8-a86e-97b09c634e00",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Clone the Repository  \n```sh\ngit clone https://github.com/your-username/HermesGPT.git\ncd HermesGPT\n```  \n### 2. Install Dependencies  \nMake sure you have Python installed, then install the required packages:  \n```sh\npip install -r requirements.txt\n```  \n### 3. Configure Database  \nSet up a PostgreSQL database with the following schema:  \n```sql\nCREATE TABLE recruiters (\nemail TEXT PRIMARY KEY,\nrecruiter_name TEXT,\ncompany_name TEXT,\nrole TEXT,\ncontacted BOOLEAN DEFAULT FALSE\n);\n```  \n### 4. Set Up Gmail API  \n1. Enable the Gmail API from Google Cloud Console.\n2. Download `credentials.json` and place it in the project directory.\n3. Run authentication:  \n```sh\npython main.py\n```  \n### 5. API Keys  \n- **Gemini AI API**: Add your Gemini API key to the `API_KEY` variable.  \n### 6. Load Recruiter Data  \nPrepare a CSV file (`recruiters.csv`) with the following columns:  \n| Email | Name | Company | Title |\n|-------|------|---------|-------|",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Setup Instructions",
                    "symbol": "Setup Instructions",
                    "chunk_idx": 2,
                    "size": 953,
                    "_id": "c1147930-c01b-59e0-a7d4-b6330fbf4ec4",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "# User Repository Map\n\nThis document maps all repositories, folders, and files in the knowledge base.\nUse this to understand the high-level structure of the portfolio.\n\n## [CaptchaOCR]\n```text\n\u251c\u2500\u2500 checkpoints\n\u251c\u2500\u2500 Metrics\n\u2502   \u251c\u2500\u2500 .gitkeep\n\u2502   \u2514\u2500\u2500 training_metrics.txt\n\u251c\u2500\u2500 src\n\u2502   \u251c\u2500\u2500 captcha_dataset.py\n\u2502   \u251c\u2500\u2500 collate.py\n\u2502   \u251c\u2500\u2500 config.py\n\u2502   \u251c\u2500\u2500 data.py\n\u2502   \u251c\u2500\u2500 generateCaptcha.py\n\u2502   \u251c\u2500\u2500 model_crnn.py\n\u2502   \u251c\u2500\u2500 plotting.py\n\u2502   \u251c\u2500\u2500 test.py\n\u2502   \u2514\u2500\u2500 vocab.py\n\u251c\u2500\u2500 .gitattributes\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 app.py\n\u251c\u2500\u2500 inference.py\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 requirements.txt\n\u251c\u2500\u2500 train.py\n\u2514\u2500\u2500 train_sanity.py\n```\n\n## [HermesGPT]\n```text\n\u251c\u2500\u2500 hermesgpt.py\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 README.md\n\u2514\u2500\u2500 requirements.txt\n```\n\n## [IntrusionBackend]\n```text\n\u251c\u2500\u2500 cross_dataset_results\n\u2502   \u251c\u2500\u2500 autoencoder_report.txt\n\u2502   \u251c\u2500\u2500 ffnn_report.txt\n\u2502   \u251c\u2500\u2500 isolation_forest_report.txt\n\u2502   \u251c\u2500\u2500 lightgbm_report.txt\n\u2502   \u251c\u2500\u2500 logreg_report.txt\n\u2502   \u251c\u2500\u2500 pipeline_report.txt\n\u2502   \u2514\u2500\u2500 xgboost_report.txt\n\u251c\u2500\u2500 models\n\u2502   \u251c\u2500\u2500 logreg_b.npy\n\u2502   \u2514\u2500\u2500 logreg_W.npy\n\u251c\u2500\u2500 scalers\n\u251c\u2500\u2500 .dockerignore\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 confusion_matrix.txt\n\u251c\u2500\u2500 cors.py\n\u251c\u2500\u2500 docker-compose.yml\n\u251c\u2500\u2500 dockerfile\n\u251c\u2500\u2500 documentation.md\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 pcap_to_cicids.py\n\u251c\u2500\u2500 predict.py\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 requirements.txt\n\u251c\u2500\u2500 router.py\n\u251c\u2500\u2500 stats.py\n\u251c\u2500\u2500 stats_cicds2018.py\n\u251c\u2500\u2500 test.py\n\u2514\u2500\u2500 utils.py\n```\n",
                "metadata": {
                    "repo": "global",
                    "path": "portfolio_graph",
                    "language": "markdown",
                    "type": "global_graph",
                    "_id": "fd1e2143-57fe-5730-96e7-c5347468f47c",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Authentication**: All sensitive endpoints are protected via `HTTPBearer` tokens.\n- **CORS**: Restricted to specific domains defined in `cors.py`.",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Security",
                    "symbol": "Security",
                    "chunk_idx": 10,
                    "size": 149,
                    "_id": "e9121e94-56a8-57b2-b4da-fc4b8b9b7252",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def evaluate_cross_dataset(dataset_path, output_dir=\"cross_dataset_results\"):\n    if not os.path.exists(output_dir):\n        os.makedirs(output_dir)\n        \n    print(f\"Loading cross-dataset validation data from {dataset_path}...\")\n    df = pl.read_parquet(dataset_path)\n    \n    y_true = df[\"Attack\"].to_numpy()\n    features_df = df.drop([\"Attack\"])\n    \n    # Identify multi-class and binary targets\n    # For binary models, we treat any non-zero class as 1 (Attack)\n    y_true_binary = (y_true != 0).astype(int)\n    \n    total_rows = len(df)\n    print(f\"Starting evaluation on {total_rows} rows...\")\n    \n    # Storage for predictions and raw scores\n    preds = {\n        \"autoencoder\": [],\n        \"isolation_forest\": [],\n        \"logreg\": [],\n        \"lightgbm\": [],\n        \"xgboost\": [],\n        \"ffnn\": [],\n        \"pipeline\": []\n    }\n    \n    scores = {\n        \"autoencoder\": [],\n        \"isolation_forest\": []\n    }\n    \n    X_numpy = features_df.to_numpy()\n    \n    # Pre-load thresholds from predict.py for raw score calculation\n    AE_THRESHOLD = predict.AE_THRESHOLD\n    ISO_THRESHOLD = predict.ISO_THRESHOLD\n    \n    print(\"Running inference...\")\n    for i in tqdm(range(total_rows)):\n        raw_sample = X_numpy[i].reshape(1, -1)\n        \n        # 1. Unsupervised Models (Getting Raw Scores for ROC AUC)\n        # Replicating predict.py logic to get scores\n        scaled_unsupervised = predict.scale_unsupervised(raw_sample)\n        \n        # Autoencoder Score\n        X_tensor = predict.torch.tensor(scaled_unsupervised, dtype=predict.torch.float32)\n        with predict.torch.no_grad():\n            reconstructed = predict.AE_MODEL(X_tensor)\n            sq_errors = (X_tensor - reconstructed) ** 2\n            mse = predict.torch.mean(sq_errors, dim=1)\n            max_err = predict.torch.max(sq_errors, dim=1).values\n            ae_score = 0.5 * (mse + max_err).item()\n        ae_flag = 1 if ae_score > AE_THRESHOLD else 0\n        \n        # Isolation Forest Score\n        iso_score = predict.ISO_FOREST.decision_function(scaled_unsupervised)[0]\n        # IF decision_function: lower is more anomalous. For ROC AUC we want higher = more anomalous\n        # so we use -score\n        iso_auc_score = -iso_score \n        iso_flag = 1 if iso_score < ISO_THRESHOLD else 0\n        \n        # 2. Supervised Models\n        lgbm_pred, _ = predict._predict_lightgbm(raw_sample)\n        xgb_pred, _ = predict._predict_xgboost(raw_sample)\n        ffnn_pred, _ = predict._predict_ffnn(raw_sample)\n        logreg_pred, _ = predict._predict_logreg(raw_sample)\n        \n        # 3. Hybrid Pipeline Logic\n        pipeline_pred = lgbm_pred if (ae_flag == 1 or iso_flag == 1) else 0\n            \n        # Store predictions\n        preds[\"autoencoder\"].append(ae_flag)\n        preds[\"isolation_forest\"].append(iso_flag)\n        preds[\"logreg\"].append(logreg_pred)\n        preds[\"lightgbm\"].append(lgbm_pred)\n        preds[\"xgboost\"].append(xgb_pred)\n        preds[\"ffnn\"].append(ffnn_pred)\n        preds[\"pipeline\"].append(pipeline_pred)\n        \n        # Store scores for AUC\n        scores[\"autoencoder\"].append(ae_score)\n        scores[\"isolation_forest\"].append(iso_auc_score)\n\n    # Define model categories for reporting\n    multiclass_models = [\"lightgbm\", \"xgboost\", \"ffnn\", \"pipeline\"]\n    binary_models = [\"autoencoder\", \"isolation_forest\", \"logreg\"]\n    \n    # CICIDS2018 subset labels\n    PRESENT_LABELS = [0, 1, 2, 3, 4]\n    from sklearn.metrics import roc_auc_score\n\n    # Generate Reports\n    for model_name, y_pred in preds.items():\n        print(f\"\\nGenerating report for: {model_name}\")\n        \n        target = y_true if model_name in multiclass_models else y_true_binary\n        labels = PRESENT_LABELS if model_name in multiclass_models else [0, 1]\n        \n        report = classification_report(target, y_pred, labels=labels)\n        cm = confusion_matrix(target, y_pred, labels=labels)\n        \n        # Save text report\n        report_file = os.path.join(output_dir, f\"{model_name}_report.txt\")\n        with open(report_file, \"w\") as f:\n            f.write(f\"=== {model_name.upper()} CROSS-DATASET VALIDATION ===\\n\")\n            if model_name in scores:\n                auc = roc_auc_score(y_true_binary, scores[model_name])\n                f.write(f\"ROC AUC SCORE: {auc:.4f}\\n\\n\")\n            f.write(report)\n            f.write(\"\\n\\n=== CONFUSION MATRIX ===\\n\")\n            f.write(str(cm))\n            \n        # Save Confusion Matrix Plot\n        plt.figure(figsize=(10, 8))\n        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n                    xticklabels=labels, yticklabels=labels)\n        title = f\"{model_name.replace('_', ' ').title()} CM\"\n        if model_name in scores:\n            title += f\" (AUC: {auc:.3f})\"\n        plt.title(f\"{title}\\n(CICIDS2018 Cross-Validation)\")\n        plt.xlabel(\"Predicted\")\n        plt.ylabel(\"Actual\")\n        plt.savefig(os.path.join(output_dir, f\"{model_name}_cm.png\"), dpi=300)\n        plt.close()\n\n    print(f\"\\nAll cross-dataset validation results saved to '{output_dir}/'\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\stats_cicds2018.py",
                    "filename": "stats_cicds2018.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 14,
                    "end_line": 142,
                    "symbol": "evaluate_cross_dataset",
                    "chunk_idx": 1,
                    "size": 5069,
                    "_id": "1e60ce24-bb92-560c-a124-ecb1ac71dabb",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Implement Dataset class** - Load and preprocess images\n2. **Build CRNN model** - CNN + BiLSTM architecture\n3. **Create training loop** - With validation and checkpoints\n4. **Add metrics** - CER and accuracy tracking\n5. **Test on small dataset** - Verify everything works\n6. **Scale to full dataset** - Train on Colab",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udee0\ufe0f Development Workflow",
                    "symbol": "\ud83d\udee0\ufe0f Development Workflow",
                    "chunk_idx": 15,
                    "size": 321,
                    "_id": "60bcb358-3110-5090-a80c-cf9343a2c6c2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def predict_attack(target_class):\n    raw_sample, idx = sampler(target_class)\n    \n    total_start = time.perf_counter()\n    \n    # Pre-scale once for unsupervised models\n    scaled_unsupervised = scale_unsupervised(raw_sample)\n    \n    # Unsupervised Check\n    ae_flag, ae_lat = _predict_autoencoder(raw_sample, scaled_data=scaled_unsupervised)\n    iso_flag, iso_lat = _predict_isolation_forest(raw_sample, scaled_data=scaled_unsupervised)\n    \n    result = {\n        \"target_class\" : int(target_class),\n        \"status\": \"Benign\",\n        \"row_index\": int(idx),\n        \"unsupervised\": {\n            \"autoencoder\": ae_flag,\n            \"isolation_forest\": iso_flag\n        },\n        \"latencies\": {\n            \"autoencoder\": round(ae_lat, 6),\n            \"isolation_forest\": round(iso_lat, 6)\n        }\n    }\n    \n    # Supervised Check \n    if ae_flag == 1 or iso_flag == 1:\n        # Pre-scale once for all supervised models\n        scaled_supervised = scale_supervised(raw_sample)\n        \n        # Final decision rests with LightGBM\n        lgbm_pred, lgbm_lat = _predict_lightgbm(raw_sample, scaled_data=scaled_supervised)\n        ffnn_pred, ffnn_lat = _predict_ffnn(raw_sample, scaled_data=scaled_supervised)\n        logreg_pred, logreg_lat = _predict_logreg(raw_sample, scaled_data=scaled_supervised)\n        xgb_pred, xgb_lat = _predict_xgboost(raw_sample, scaled_data=scaled_supervised)\n        \n        if lgbm_pred != 0:\n            result[\"status\"] = \"Attack Detected\"\n            \n        result[\"supervised\"] = {\n            \"ffnn\": ffnn_pred,\n            \"lightgbm\": lgbm_pred,\n            \"logreg\": logreg_pred,\n            \"xgboost\": xgb_pred\n        }\n        result[\"latencies\"].update({\n            \"ffnn\": round(ffnn_lat, 6),\n            \"lightgbm\": round(lgbm_lat, 6),\n            \"logreg\": round(logreg_lat, 6),\n            \"xgboost\": round(xgb_lat, 6)\n        })\n    \n    result[\"total_detection_time\"] = round(time.perf_counter() - total_start, 6)\n    return result",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\predict.py",
                    "filename": "predict.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 191,
                    "end_line": 245,
                    "symbol": "predict_attack",
                    "chunk_idx": 12,
                    "size": 1994,
                    "_id": "803ced83-482a-56ff-bc11-d9bed9fb318d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def predict_attack_by_idx(idx):\n    raw_sample, target_class = sample_by_index(idx)\n    \n    total_start = time.perf_counter()\n    \n    # Pre-scale once for unsupervised models\n    scaled_unsupervised = scale_unsupervised(raw_sample)\n    \n    # Unsupervised Check\n    ae_flag, ae_lat = _predict_autoencoder(raw_sample, scaled_data=scaled_unsupervised)\n    iso_flag, iso_lat = _predict_isolation_forest(raw_sample, scaled_data=scaled_unsupervised)\n    \n    result = {\n        \"target_class\" : int(target_class),\n        \"status\": \"Benign\",\n        \"row_index\": int(idx),\n        \"unsupervised\": {\n            \"autoencoder\": ae_flag,\n            \"isolation_forest\": iso_flag\n        },\n        \"latencies\": {\n            \"autoencoder\": round(ae_lat, 6),\n            \"isolation_forest\": round(iso_lat, 6)\n        }\n    }\n    \n    # Supervised Check \n    if ae_flag == 1 or iso_flag == 1:\n        # Pre-scale once for all supervised models\n        scaled_supervised = scale_supervised(raw_sample)\n        \n        # Final decision rests with LightGBM\n        lgbm_pred, lgbm_lat = _predict_lightgbm(raw_sample, scaled_data=scaled_supervised)\n        ffnn_pred, ffnn_lat = _predict_ffnn(raw_sample, scaled_data=scaled_supervised)\n        logreg_pred, logreg_lat = _predict_logreg(raw_sample, scaled_data=scaled_supervised)\n        xgb_pred, xgb_lat = _predict_xgboost(raw_sample, scaled_data=scaled_supervised)\n        \n        if lgbm_pred != 0:\n            result[\"status\"] = \"Attack Detected\"\n            \n        result[\"supervised\"] = {\n            \"ffnn\": ffnn_pred,\n            \"lightgbm\": lgbm_pred,\n            \"logreg\": logreg_pred,\n            \"xgboost\": xgb_pred\n        }\n        result[\"latencies\"].update({\n            \"ffnn\": round(ffnn_lat, 6),\n            \"lightgbm\": round(lgbm_lat, 6),\n            \"logreg\": round(logreg_lat, 6),\n            \"xgboost\": round(xgb_lat, 6)\n        })\n    \n    result[\"total_detection_time\"] = round(time.perf_counter() - total_start, 6)\n    return result",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\predict.py",
                    "filename": "predict.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 248,
                    "end_line": 302,
                    "symbol": "predict_attack_by_idx",
                    "chunk_idx": 13,
                    "size": 2000,
                    "_id": "fc2074a0-d59e-5662-9666-723b82d8560a",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def main():\n    # Setup\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    print(f\"Using device: {device}\")\n    \n    os.makedirs(cfg.RESULT_DIR, exist_ok=True)\n    \n    try:\n        # Load trained model\n        print(\"Loading trained model...\")\n        model = load_model()\n        model = model.to(device)\n        print(\"Model loaded successfully!\")\n        \n        # Generate test CAPTCHAs\n        print(\"\\nGenerating enhanced test CAPTCHAs...\")\n        test_cases = []\n        \n        for i in range(4):\n            # Generate random text\n            text = ''.join(random.choices(cfg.chars, k=random.randint(cfg.CAPTCHA_LEN_LOWER_LIMIT, cfg.CAPTCHA_LEN_UPPER_LIMIT)))\n            filename = f\"{text}_{i}.png\"\n            \n            # Generate enhanced image\n            image_path = generate_test_captcha(text, filename, width=cfg.W_max, height=cfg.H)\n            test_cases.append((text, image_path, \"\"))  # Add empty prediction slot\n        \n        # Run inference\n        print(\"\\nRunning inference...\")\n        print(\"-\" * 60)\n        print(f\"{'Target':<15} {'Prediction':<15} {'Correct':<10} {'Image':<20}\")\n        print(\"-\" * 60)\n        \n        correct_count = 0\n        for i, (target_text, image_path, _) in enumerate(test_cases):\n            try:\n                # Preprocess image\n                image_tensor = preprocess_image(image_path)\n                \n                # Run prediction\n                prediction = predict_captcha(model, image_tensor, device)\n                \n                # Store prediction in test_cases\n                test_cases[i] = (target_text, image_path, prediction)\n                \n                # Check if correct\n                is_correct = prediction == target_text\n                if is_correct:\n                    correct_count += 1\n                \n                # Display result\n                status = \"CORRECT\" if is_correct else \"WRONG\"\n                print(f\"{target_text:<15} {prediction:<15} {status:<10} {os.path.basename(image_path):<20}\")\n                \n            except Exception as e:\n                print(f\"Error processing {image_path}: {e}\")\n        \n        # Summary\n        print(\"-\" * 60)\n        accuracy = (correct_count / len(test_cases)) * 100\n        print(f\"Overall Accuracy: {correct_count}/{len(test_cases)} ({accuracy:.1f}%)\")\n        \n        # Calculate individual character accuracy\n        total_chars = 0\n        correct_chars = 0\n        for target_text, _, prediction in test_cases:\n            total_chars += len(target_text)\n            # Count correct characters (position by position)\n            min_len = min(len(target_text), len(prediction))\n            for i in range(min_len):\n                if target_text[i] == prediction[i]:\n                    correct_chars += 1\n        \n        char_accuracy = (correct_chars / total_chars) * 100 if total_chars > 0 else 0\n        print(f\"Character Accuracy: {correct_chars}/{total_chars} ({char_accuracy:.1f}%)\")\n        \n        if accuracy >= 80:\n            print(\"Excellent performance!\")\n        elif accuracy >= 60:\n            print(\"Good performance!\")\n        else:\n            print(\"Room for improvement...\")\n        \n        # Create and save results plot\n        print(\"\\nGenerating results visualization...\")\n        try:\n            metrics = TrainingMetrics()\n            image_paths = [case[1] for case in test_cases]\n            predictions = [case[2] for case in test_cases]\n            targets = [case[0] for case in test_cases]\n            \n            # Create results directory if it doesn't exist\n            os.makedirs(\"Metrics\", exist_ok=True)\n            \n            # Plot results\n            metrics.plot_results(image_paths, predictions, targets)\n            print(\"Results plot generated successfully!\")\n            \n        except Exception as e:\n            print(f\"Warning: Could not generate plot: {e}\")\n            \n    except Exception as e:\n        print(f\"Error: {e}\")\n        print(\"Make sure you have a trained model in checkpoints/best_model.pth\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 85,
                    "end_line": 188,
                    "symbol": "main",
                    "chunk_idx": 5,
                    "size": 4081,
                    "_id": "bbc4b28d-076a-558f-95dd-62ffcd39457f",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def get_recruiters(batch_size=40):\n    try:\n        conn = connect_db()\n        cursor = conn.cursor()\n        query = \"\"\"\n        SELECT email,recruiter_name,company_name, role FROM recruiters WHERE contacted = FALSE LIMIT %s;\n        \"\"\"\n        cursor.execute(query,(batch_size,))\n\n        recruiters = cursor.fetchall()\n        \n    except Exception as e:\n        print(f\"Error {e} occurred\")\n    finally:\n        cursor.close()\n        conn.close()\n\n        return recruiters",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 54,
                    "end_line": 71,
                    "symbol": "get_recruiters",
                    "chunk_idx": 3,
                    "size": 480,
                    "_id": "9039f7d6-9c5d-523b-ba48-d7e54e6d9fd1",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def _flow_to_row(fs: FlowStats, label: str = \"BENIGN\") -> Dict:\n    dur_us  = max(1, fs.last_ts - fs.start_ts)\n    dur_s   = dur_us / 1_000_000\n\n    all_pkts = fs.fwd_pkts + fs.bwd_pkts\n    tot_pkts = len(all_pkts)\n    tot_bytes = sum(all_pkts)\n\n    fw = len(fs.fwd_pkts); bw = len(fs.bwd_pkts)\n    fb = sum(fs.fwd_pkts); bb = sum(fs.bwd_pkts)\n\n    # packet-length stats\n    fl_mean, fl_std, fl_max, fl_min = _safe_stats(all_pkts)\n    fw_mean, fw_std, fw_max, fw_min = _safe_stats(fs.fwd_pkts)\n    bw_mean, bw_std, bw_max, bw_min = _safe_stats(fs.bwd_pkts)\n\n    # IAT stats\n    fi_mean, fi_std, fi_max, fi_min = _safe_stats(fs.flow_iats)\n    fwi_mean, fwi_std, fwi_max, fwi_min = _safe_stats(fs.fwd_iats)\n    bwi_mean, bwi_std, bwi_max, bwi_min = _safe_stats(fs.bwd_iats)\n\n    # rates\n    flow_bps  = tot_bytes / dur_s  if dur_s > 0 else 0\n    flow_pps  = tot_pkts  / dur_s  if dur_s > 0 else 0\n    fwd_bps   = fb / dur_s         if dur_s > 0 else 0\n    bwd_bps   = bb / dur_s         if dur_s > 0 else 0\n\n    # active / idle\n    act_mean, act_std, act_max, act_min = _safe_stats(fs.active_times)\n    idl_mean, idl_std, idl_max, idl_min = _safe_stats(fs.idle_times)\n\n    # subflow (simple: treat whole flow as one subflow)\n    sf_fwd_pkts  = fw\n    sf_fwd_bytes = fb\n    sf_bwd_pkts  = bw\n    sf_bwd_bytes = bb\n\n    # bulk stats (simplified: avg bytes per active burst)\n    fwd_bulk_rate = fb / max(1, len(fs.active_times)) if fs.active_times else 0\n    bwd_bulk_rate = bb / max(1, len(fs.active_times)) if fs.active_times else 0\n\n    # PSH/URG counts\n    fwd_psh_flags = fs.fwd_psh; bwd_psh_flags = fs.bwd_psh\n    fwd_urg_flags = fs.fwd_urg; bwd_urg_flags = fs.bwd_urg\n\n    # min/max segment size (approx from packet lengths)\n    fwd_seg_size = fw_mean\n    bwd_seg_size = bw_mean\n\n    # header length estimates (TCP=20, UDP=8)\n    proto_hdr = 20 if fs.proto == 6 else 8\n    fwd_hdr_len = proto_hdr * fw\n    bwd_hdr_len = proto_hdr * bw\n\n    # down/up ratio\n    down_up = bb / max(1, fb)\n\n    row = {\n        \" Source IP\":          fs.src_ip,\n        \" Source Port\":        fs.src_port,\n        \" Destination IP\":     fs.dst_ip,\n        \" Destination Port\":   fs.dst_port,\n        \" Protocol\":           fs.proto,\n        \" Flow Duration\":      dur_us,\n        \" Total Fwd Packets\":  fw,\n        \" Total Backward Packets\": bw,\n        \"Total Length of Fwd Packets\": fb,\n        \" Total Length of Bwd Packets\": bb,\n        \" Fwd Packet Length Max\": fw_max,\n        \" Fwd Packet Length Min\": fw_min,\n        \" Fwd Packet Length Mean\": fw_mean,\n        \" Fwd Packet Length Std\": fw_std,\n        \"Bwd Packet Length Max\": bw_max,\n        \" Bwd Packet Length Min\": bw_min,\n        \" Bwd Packet Length Mean\": bw_mean,\n        \" Bwd Packet Length Std\": bw_std,\n        \"Flow Bytes/s\":        flow_bps,\n        \" Flow Packets/s\":     flow_pps,\n        \" Flow IAT Mean\":      fi_mean,\n        \" Flow IAT Std\":       fi_std,\n        \" Flow IAT Max\":       fi_max,\n        \" Flow IAT Min\":       fi_min,\n        \"Fwd IAT Total\":       sum(fs.fwd_iats),\n        \" Fwd IAT Mean\":       fwi_mean,\n        \" Fwd IAT Std\":        fwi_std,\n        \" Fwd IAT Max\":        fwi_max,\n        \" Fwd IAT Min\":        fwi_min,\n        \"Bwd IAT Total\":       sum(fs.bwd_iats),\n        \" Bwd IAT Mean\":       bwi_mean,\n        \" Bwd IAT Std\":        bwi_std,\n        \" Bwd IAT Max\":        bwi_max,\n        \" Bwd IAT Min\":        bwi_min,\n        \"Fwd PSH Flags\":       fwd_psh_flags,\n        \" Bwd PSH Flags\":      bwd_psh_flags,\n        \" Fwd URG Flags\":      fwd_urg_flags,\n        \" Bwd URG Flags\":      bwd_urg_flags,\n        \" Fwd Header Length\":  fwd_hdr_len,\n        \" Bwd Header Length\":  bwd_hdr_len,\n        \"Fwd Packets/s\":       fw / dur_s if dur_s > 0 else 0,\n        \" Bwd Packets/s\":      bw / dur_s if dur_s > 0 else 0,\n        \" Min Packet Length\":  fl_min,\n        \" Max Packet Length\":  fl_max,\n        \" Packet Length Mean\": fl_mean,\n        \" Packet Length Std\":  fl_std,\n        \" Packet Length Variance\": fl_std ** 2,\n        \"FIN Flag Count\":      fs.fwd_fin + fs.bwd_fin,\n        \" SYN Flag Count\":     fs.fwd_syn + fs.bwd_syn,\n        \" RST Flag Count\":     fs.fwd_rst + fs.bwd_rst,\n        \" PSH Flag Count\":     fs.fwd_psh + fs.bwd_psh,\n        \" ACK Flag Count\":     fs.fwd_ack + fs.bwd_ack,\n        \" URG Flag Count\":     fs.fwd_urg + fs.bwd_urg,\n        \" CWE Flag Count\":     0,\n        \" ECE Flag Count\":     0,\n        \" Down/Up Ratio\":      down_up,\n        \" Average Packet Size\": fl_mean,\n        \" Avg Fwd Segment Size\": fwd_seg_size,\n        \" Avg Bwd Segment Size\": bwd_seg_size,\n        \" Fwd Header Length.1\": fwd_hdr_len,\n        \"Fwd Avg Bytes/Bulk\":  fwd_bulk_rate,\n        \" Fwd Avg Packets/Bulk\": fw / max(1, len(fs.active_times)) if fs.active_times else fw,\n        \" Fwd Avg Bulk Rate\":  fwd_bulk_rate,\n        \" Bwd Avg Bytes/Bulk\": bwd_bulk_rate,\n        \" Bwd Avg Packets/Bulk\": bw / max(1, len(fs.active_times)) if fs.active_times else bw,\n        \"Bwd Avg Bulk Rate\":   bwd_bulk_rate,\n        \"Subflow Fwd Packets\": sf_fwd_pkts,\n        \" Subflow Fwd Bytes\":  sf_fwd_bytes,\n        \" Subflow Bwd Packets\": sf_bwd_pkts,\n        \" Subflow Bwd Bytes\":  sf_bwd_bytes,\n        \"Init_Win_bytes_forward\":  0,\n        \" Init_Win_bytes_backward\": 0,\n        \" act_data_pkt_fwd\":   fw,\n        \" min_seg_size_forward\": fw_min,\n        \"Active Mean\":         act_mean,\n        \" Active Std\":         act_std,\n        \" Active Max\":         act_max,\n        \" Active Min\":         act_min,\n        \"Idle Mean\":           idl_mean,\n        \" Idle Std\":           idl_std,\n        \" Idle Max\":           idl_max,\n        \" Idle Min\":           idl_min,\n        \" Label\":              label,\n    }\n    return row",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\pcap_to_cicids.py",
                    "filename": "pcap_to_cicids.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 183,
                    "end_line": 325,
                    "symbol": "_flow_to_row",
                    "chunk_idx": 7,
                    "size": 5725,
                    "_id": "19437a4c-c23a-51d0-b1b3-761e804df850",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def mark_as_contacted(email):\n    try:\n        conn = connect_db()\n        cursor = conn.cursor()\n        query = \"\"\"\n        UPDATE  recruiters SET contacted = TRUE WHERE email = %s;\n        \"\"\"\n        cursor.execute(query,(email,))\n        conn.commit()\n    except Exception as e:\n        print(f\"Eror {e} occurred\")\n    finally:\n        cursor.close()\n        conn.close()",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 73,
                    "end_line": 86,
                    "symbol": "mark_as_contacted",
                    "chunk_idx": 4,
                    "size": 376,
                    "_id": "6a84ce36-1d5b-52d8-8ca4-685ed21a2719",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def load_recruiters(csv_path):\n    try:\n        recruiters = pd.read_csv(csv_path)\n        conn = connect_db()\n        cursor = conn.cursor()\n        query = \"\"\"\n        INSERT INTO recruiters (email,recruiter_name,company_name,role)\n        VALUES (%s,%s,%s,%s) \n        ON CONFLICT (email) DO NOTHING;\n        \"\"\"\n        for idx,row in recruiters.iterrows():\n            cursor.execute(query,(row[\"Email\"],row['Name'],row['Company'],row['Title']))\n            print(f\"Row {idx} with name {row['Name']} executed properly\")\n        conn.commit()\n    except Exception as e:\n        conn.rollback()\n        print(f\"Eror occured {e}\")\n    finally:\n        cursor.close()\n        conn.close()",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 33,
                    "end_line": 52,
                    "symbol": "load_recruiters",
                    "chunk_idx": 2,
                    "size": 689,
                    "_id": "4229b491-9ee7-52f2-b8d8-dc4310aca3b1",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- \ud83d\udcc4 **Resume Parsing**: Loads and processes resume data for personalized email generation.\n- \ud83e\udd16 **AI-Powered Emails**: Uses Gemini AI to generate tailored cold emails.\n- \ud83d\udcec **Automated Email Sending**: Sends emails via Gmail API with attachments.\n- \u2705 **Email Verification**: Uses SMTP and Maileroo API to validate emails before sending.\n- \ud83d\uddc4 **Database Management**: Stores recruiter data in PostgreSQL and tracks outreach progress.\n- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Features",
                    "symbol": "Features",
                    "chunk_idx": 1,
                    "size": 529,
                    "_id": "2b1ec077-3dbf-5a35-8275-b58b0b6597fd",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def predict_captcha(model, image_tensor, device):\n    \"\"\"Run inference on a single image.\"\"\"\n    with torch.no_grad():\n        # Move to device\n        image_tensor = image_tensor.to(device)\n        \n        # Forward pass\n        logits = model(image_tensor)\n        \n        # Decode prediction\n        prediction = ctc_greedy_decode(logits)\n        \n        return prediction[0] if prediction else \"\"",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 58,
                    "end_line": 70,
                    "symbol": "predict_captcha",
                    "chunk_idx": 3,
                    "size": 403,
                    "_id": "fb192dc6-35e9-5c2e-b704-85fe4ef1c54d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Training\n```bash\npython train.py\n```\n- **Automatic early stopping** prevents overfitting\n- **Real-time metrics** and sample predictions\n- **Checkpoint saving** for best model  \n### Inference\n```bash\npython inference.py\n```\n- **Loads best trained model** automatically\n- **Generates test CAPTCHAs** for evaluation\n- **Shows both overall and character accuracy**\n- **Creates visualization plots** in Metrics folder",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfae Usage",
                    "symbol": "\ud83c\udfae Usage",
                    "chunk_idx": 8,
                    "size": 416,
                    "_id": "e344aa2e-82e5-5145-958a-5254a76f5667",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence\n- **Model Architecture**: CRNN produces correct output shapes (64\u00d7batch\u00d763) with H=60, W=256\n- **Data Loading**: Proper image preprocessing and CTC batching\n- **Full CAPTCHA Recognition**: Model now recognizes complete CAPTCHA sequences\n- **Inference Pipeline**: Complete inference script with visualization and accuracy metrics\n- **Early Stopping**: Enhanced early stopping prevents overfitting automatically\n- **High Accuracy**: 75-100% overall accuracy, 25/26+ character accuracy (96%+)  \n### \ud83c\udfaf Training Status\n- **Current**: Epoch 8, excellent convergence achieved\n- **Best Model**: Validation loss 0.1782, early stopping working perfectly\n- **Performance**: 75-100% accuracy on fresh CAPTCHAs (varies by run)  \n### \ud83d\udcca Training Results\n![Training Losses](Metrics/training_losses.png)\n![Loss Comparison](Metrics/loss_comparison.png)  \n**Key Insights:**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 4,
                    "size": 953,
                    "_id": "594be5fe-581c-57f0-b467-0938c58aa712",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def preprocess_image(image_path, target_size=(cfg.W_max, cfg.H)):\n    \"\"\"Preprocess image for inference (same as training).\"\"\"\n    # Load image\n    if not os.path.exists(image_path):\n        raise FileNotFoundError(f\"Image not found: {image_path}\")\n    \n    # Read and preprocess\n    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE if cfg.grayscale else cv2.IMREAD_COLOR)\n    if img is None:\n        raise ValueError(f\"Failed to load image: {image_path}\")\n    \n    # Resize to target dimensions\n    img = cv2.resize(img, target_size)\n    \n    # Convert to tensor and normalize\n    img_tensor = torch.from_numpy(img).float() / 255.0\n    \n    # Add batch and channel dimensions\n    if cfg.grayscale:\n        img_tensor = img_tensor.unsqueeze(0).unsqueeze(0)  # [1, 1, H, W]\n    else:\n        img_tensor = img_tensor.permute(2, 0, 1).unsqueeze(0)  # [1, 3, H, W]\n    \n    return img_tensor",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 33,
                    "end_line": 56,
                    "symbol": "preprocess_image",
                    "chunk_idx": 2,
                    "size": 888,
                    "_id": "3d9a8566-e6a1-5788-985a-649fa1569bbc",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "The project follows a modular architecture designed for low-latency inference and high throughput.  \n```mermaid\ngraph TD\nA[Network Traffic / PCAP] -->|Feature Extraction| B(CICIDS Features)\nB --> C{Hybrid Pipeline}\nC --> D[Unsupervised Layer]\nD -->|Anomalies Flagged| E[Supervised Layer]\nE -->|Final Classification| F[Actionable Insight]\nD -->|Benign| G[Safe Traffic]\n```  \n### Machine Learning Pipeline\nThe core of this project is a **Hierarchical Detection Strategy**:  \n1.  **Unsupervised Layer (The Flaggers)**:\n- **Autoencoder**: Reconstructs input data; high reconstruction error indicates an anomaly.\n- **Isolation Forest**: Detects anomalies by isolating observations in feature space.\n- *Logic*: If either model flags the traffic, it proceeds to the next stage.  \n2.  **Supervised Layer (The Judges)**:\n- **LightGBM (Final Veto)**: A gradient boosting framework that provides the final classification.",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "System Architecture",
                    "symbol": "System Architecture",
                    "chunk_idx": 1,
                    "size": 910,
                    "_id": "755fce9d-1447-54ea-9959-5a3136e676ba",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "- **Hierarchical ML Pipeline**: Combines Unsupervised Anomaly Detection (Autoencoders, Isolation Forests) with Supervised Classification (LightGBM, XGBoost, FFNN).\n- **Real-time Inference**: Optimized for low-latency network flow analysis.\n- **WebSocket Streaming**: Stream and evaluate massive datasets with live accuracy telemetry.\n- **Secure by Design**: Token-based authentication and restricted CORS policies.\n- **Containerized**: Ready for deployment via Docker and Docker Compose.\n- **Detailed Analytics**: Built-in tools for generating confusion matrices and classification reports.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Key Features",
                    "symbol": "Key Features",
                    "chunk_idx": 2,
                    "size": 596,
                    "_id": "2f101085-ba79-5828-8cac-b2324f51d4c6",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def websocket_stream(websocket: WebSocket):\n    await websocket.accept()\n    try:\n        # Expected JSON: {\"command\": \"start\", \"start_at\": 0}\n        initial_data = await websocket.receive_json()\n        \n        if initial_data.get(\"command\") == \"start\":\n            # Token Check\n            if initial_data.get(\"token\") != API_TOKEN:\n                await websocket.send_json({\"error\": \"Unauthorized\"})\n                await websocket.close(code=1008)\n                return\n            \n            await websocket.send_json({\"status\": \"Authentication Successful\", \"message\": \"Stream starting...\"})\n                \n            start_idx = initial_data.get(\"start_at\", 0)\n            batch_size = 100\n            total_rows = len_df()\n            \n            # Statistics tracking\n            stats = {\n                \"total_processed\": 0,\n                \"correct_predictions\": 0,\n                \"actual_counts\": {},\n                \"predicted_counts\": {},\n                \"total_latencies\": {\n                    \"autoencoder\": 0.0,\n                    \"isolation_forest\": 0.0,\n                    \"ffnn\": 0.0,\n                    \"lightgbm\": 0.0,\n                    \"logreg\": 0.0,\n                    \"xgboost\": 0.0,\n                    \"pipeline\": 0.0\n                },\n                \"latency_counts\": {\n                    \"autoencoder\": 0,\n                    \"isolation_forest\": 0,\n                    \"ffnn\": 0,\n                    \"lightgbm\": 0,\n                    \"logreg\": 0,\n                    \"xgboost\": 0,\n                    \"pipeline\": 0\n                }\n            }\n            \n            for i in range(start_idx, total_rows, batch_size):\n                batch_results = []\n                end_idx = min(i + batch_size, total_rows)\n\n                loop = asyncio.get_event_loop()\n                for idx in range(i, end_idx):\n                    result = await loop.run_in_executor(None,predict.predict_attack_by_idx,idx)\n                    batch_results.append(result)\n                    \n                    # Update Statistics\n                    actual = str(result[\"target_class\"])\n                    # Use LightGBM prediction for accuracy tracking\n                    predicted = str(result.get(\"supervised\", {}).get(\"lightgbm\", 0)) if result[\"status\"] == \"Attack Detected\" else \"0\"\n                    \n                    stats[\"total_processed\"] += 1\n                    if actual == predicted:\n                        stats[\"correct_predictions\"] += 1\n                    \n                    stats[\"actual_counts\"][actual] = stats[\"actual_counts\"].get(actual, 0) + 1\n                    stats[\"predicted_counts\"][predicted] = stats[\"predicted_counts\"].get(predicted, 0) + 1\n\n                    # Update Latencies\n                    res_lats = result.get(\"latencies\", {})\n                    for model, lat in res_lats.items():\n                        if model in stats[\"total_latencies\"]:\n                            stats[\"total_latencies\"][model] += lat\n                            stats[\"latency_counts\"][model] += 1\n                    \n                    stats[\"total_latencies\"][\"pipeline\"] += result.get(\"total_detection_time\", 0)\n                    stats[\"latency_counts\"][\"pipeline\"] += 1\n                \n                # Calculate current accuracy for this snapshot\n                current_acc = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n                \n                # Send the batch with real-time stats\n                await websocket.send_json({\n                    \"type\": \"batch\",\n                    \"batch_start\": i,\n                    \"batch_end\": end_idx,\n                    \"data\": batch_results,\n                    \"current_statistics\": {\n                        \"accuracy\": round(current_acc, 4),\n                        \"total_processed\": stats[\"total_processed\"],\n                        \"correct_predictions\": stats[\"correct_predictions\"]\n                    }\n                })\n                \n                await asyncio.sleep(0.01)\n            \n            # Send Final Statistics\n            accuracy = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n            \n            # Calculate Average Latencies\n            avg_latencies = {\n                model: round(stats[\"total_latencies\"][model] / stats[\"latency_counts\"][model], 6)\n                if stats[\"latency_counts\"][model] > 0 else 0\n                for model in stats[\"total_latencies\"]\n            }\n\n            await websocket.send_json({\n                \"type\": \"summary\",\n                \"status\": \"Stream Complete\",\n                \"statistics\": {\n                    \"accuracy\": round(accuracy, 4),\n                    \"total_processed\": stats[\"total_processed\"],\n                    \"correct_predictions\": stats[\"correct_predictions\"],\n                    \"actual_counts\": stats[\"actual_counts\"],\n                    \"predicted_counts\": stats[\"predicted_counts\"],\n                    \"average_latencies\": avg_latencies\n                }\n            })\n            \n            # Close connection after finishing the task\n            await websocket.close(code=1000)\n                \n    except WebSocketDisconnect:\n        print(f\"WebSocket client disconnected.\")\n    except Exception as e:\n        print(f\"WebSocket error: {str(e)}\")\n        await websocket.close(code=1011)",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 191,
                    "end_line": 315,
                    "symbol": "websocket_stream",
                    "chunk_idx": 15,
                    "size": 5449,
                    "_id": "4d64eb89-57c0-5ee0-91e1-1073db67be4d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`\n- `POST /predict/autoencoder`\n- `POST /predict/isolationForest`\n- `POST /predict/xgboost`  \n---  \n### WebSocket Streaming\n`WS /intrusiondetection/ws/stream`\nStreams the dataset in batches of 100 rows with real-time statistics.  \n**Initialization Message**:\nAfter connecting, send the following JSON:\n```json\n{\n\"command\": \"start\",\n\"token\": \"your_secure_token_here\",\n\"start_at\": 0\n}\n```  \n**Final Summary Message**:\nAt the end of the stream, the server sends a summary containing final statistics and average latencies:\n```json\n{\n\"type\": \"summary\",\n\"status\": \"Stream Complete\",\n\"statistics\": {\n\"accuracy\": 0.85,\n\"total_processed\": 1000,\n\"correct_predictions\": 850,\n\"actual_counts\": {\"0\": 100, \"1\": 750, ...},\n\"predicted_counts\": {\"0\": 120, \"1\": 730, ...},\n\"average_latencies\": {\n\"autoencoder\": 0.000123,\n\"isolation_forest\": 0.000045,\n\"ffnn\": 0.000456,\n\"lightgbm\": 0.000789,\n\"logreg\": 0.000012,\n\"xgboost\": 0.000890,",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 5,
                    "size": 987,
                    "_id": "28326c1c-8329-5ba1-adda-3be25637f266",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def predict_captcha(model, image_tensor, device):\n    \"\"\"Run inference on a single image.\"\"\"\n    with torch.no_grad():\n        # Move to device\n        image_tensor = image_tensor.to(device)\n        \n        # Forward pass\n        logits = model(image_tensor)\n        \n        # Decode prediction\n        prediction = ctc_greedy_decode(logits)\n        \n        return prediction[0] if prediction else \"\"",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 58,
                    "end_line": 70,
                    "symbol": "predict_captcha",
                    "chunk_idx": 3,
                    "size": 403,
                    "_id": "fb192dc6-35e9-5c2e-b704-85fe4ef1c54d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def main():\n    # Setup\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    print(f\"Using device: {device}\")\n    \n    os.makedirs(cfg.RESULT_DIR, exist_ok=True)\n    \n    try:\n        # Load trained model\n        print(\"Loading trained model...\")\n        model = load_model()\n        model = model.to(device)\n        print(\"Model loaded successfully!\")\n        \n        # Generate test CAPTCHAs\n        print(\"\\nGenerating enhanced test CAPTCHAs...\")\n        test_cases = []\n        \n        for i in range(4):\n            # Generate random text\n            text = ''.join(random.choices(cfg.chars, k=random.randint(cfg.CAPTCHA_LEN_LOWER_LIMIT, cfg.CAPTCHA_LEN_UPPER_LIMIT)))\n            filename = f\"{text}_{i}.png\"\n            \n            # Generate enhanced image\n            image_path = generate_test_captcha(text, filename, width=cfg.W_max, height=cfg.H)\n            test_cases.append((text, image_path, \"\"))  # Add empty prediction slot\n        \n        # Run inference\n        print(\"\\nRunning inference...\")\n        print(\"-\" * 60)\n        print(f\"{'Target':<15} {'Prediction':<15} {'Correct':<10} {'Image':<20}\")\n        print(\"-\" * 60)\n        \n        correct_count = 0\n        for i, (target_text, image_path, _) in enumerate(test_cases):\n            try:\n                # Preprocess image\n                image_tensor = preprocess_image(image_path)\n                \n                # Run prediction\n                prediction = predict_captcha(model, image_tensor, device)\n                \n                # Store prediction in test_cases\n                test_cases[i] = (target_text, image_path, prediction)\n                \n                # Check if correct\n                is_correct = prediction == target_text\n                if is_correct:\n                    correct_count += 1\n                \n                # Display result\n                status = \"CORRECT\" if is_correct else \"WRONG\"\n                print(f\"{target_text:<15} {prediction:<15} {status:<10} {os.path.basename(image_path):<20}\")\n                \n            except Exception as e:\n                print(f\"Error processing {image_path}: {e}\")\n        \n        # Summary\n        print(\"-\" * 60)\n        accuracy = (correct_count / len(test_cases)) * 100\n        print(f\"Overall Accuracy: {correct_count}/{len(test_cases)} ({accuracy:.1f}%)\")\n        \n        # Calculate individual character accuracy\n        total_chars = 0\n        correct_chars = 0\n        for target_text, _, prediction in test_cases:\n            total_chars += len(target_text)\n            # Count correct characters (position by position)\n            min_len = min(len(target_text), len(prediction))\n            for i in range(min_len):\n                if target_text[i] == prediction[i]:\n                    correct_chars += 1\n        \n        char_accuracy = (correct_chars / total_chars) * 100 if total_chars > 0 else 0\n        print(f\"Character Accuracy: {correct_chars}/{total_chars} ({char_accuracy:.1f}%)\")\n        \n        if accuracy >= 80:\n            print(\"Excellent performance!\")\n        elif accuracy >= 60:\n            print(\"Good performance!\")\n        else:\n            print(\"Room for improvement...\")\n        \n        # Create and save results plot\n        print(\"\\nGenerating results visualization...\")\n        try:\n            metrics = TrainingMetrics()\n            image_paths = [case[1] for case in test_cases]\n            predictions = [case[2] for case in test_cases]\n            targets = [case[0] for case in test_cases]\n            \n            # Create results directory if it doesn't exist\n            os.makedirs(\"Metrics\", exist_ok=True)\n            \n            # Plot results\n            metrics.plot_results(image_paths, predictions, targets)\n            print(\"Results plot generated successfully!\")\n            \n        except Exception as e:\n            print(f\"Warning: Could not generate plot: {e}\")\n            \n    except Exception as e:\n        print(f\"Error: {e}\")\n        print(\"Make sure you have a trained model in checkpoints/best_model.pth\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 85,
                    "end_line": 188,
                    "symbol": "main",
                    "chunk_idx": 5,
                    "size": 4081,
                    "_id": "bbc4b28d-076a-558f-95dd-62ffcd39457f",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "with gr.Blocks(title=\"CAPTCHA OCR (checkpoint)\") as demo:\n    gr.Markdown(\"## CAPTCHA OCR \")\n\n    with gr.Row():\n        # Left column: Generate button + Solve button stacked vertically\n        with gr.Column(scale=1):\n            gen_btn = gr.Button(\"Generate CAPTCHA\", variant=\"primary\")\n            solve_btn = gr.Button(\"Solve\", interactive=False, variant=\"secondary\")\n        \n        # Right column: Ground Truth\n        gt_out = gr.Textbox(label=\"Ground Truth\", interactive=False, text_align=\"center\")\n\n    with gr.Row():\n        img_out = gr.Image(label=\"Generated CAPTCHA\", type=\"pil\")\n        path_box = gr.Textbox(label=\"Internal Path\", interactive=False, visible=False)\n\n    # Prediction row split into two columns\n    with gr.Row():\n        accuracy_out = gr.Textbox(label=\"Character Accuracy\", interactive=False, text_align=\"center\")\n        pred_out = gr.Textbox(label=\"Prediction\", interactive=False, text_align=\"center\")\n\n    # Generate: outputs image, ground truth, path, and enables Solve (green)\n    gen_btn.click(\n        fn=ui_generate,\n        outputs=[img_out, gt_out, path_box, solve_btn],\n    )\n\n    # Solve: only uses the internal path (no upload option anymore)\n    solve_btn.click(\n        fn=ui_solve,\n        inputs=[path_box, gt_out],\n        outputs=[accuracy_out, pred_out],\n    )\nif __name__ == \"__main__\":\n    demo.launch()",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\app.py",
                    "filename": "app.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 66,
                    "end_line": 101,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 1359,
                    "_id": "d33e2103-8a96-5c78-a5ce-4f9aff805aa9",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def evaluate_cross_dataset(dataset_path, output_dir=\"cross_dataset_results\"):\n    if not os.path.exists(output_dir):\n        os.makedirs(output_dir)\n        \n    print(f\"Loading cross-dataset validation data from {dataset_path}...\")\n    df = pl.read_parquet(dataset_path)\n    \n    y_true = df[\"Attack\"].to_numpy()\n    features_df = df.drop([\"Attack\"])\n    \n    # Identify multi-class and binary targets\n    # For binary models, we treat any non-zero class as 1 (Attack)\n    y_true_binary = (y_true != 0).astype(int)\n    \n    total_rows = len(df)\n    print(f\"Starting evaluation on {total_rows} rows...\")\n    \n    # Storage for predictions and raw scores\n    preds = {\n        \"autoencoder\": [],\n        \"isolation_forest\": [],\n        \"logreg\": [],\n        \"lightgbm\": [],\n        \"xgboost\": [],\n        \"ffnn\": [],\n        \"pipeline\": []\n    }\n    \n    scores = {\n        \"autoencoder\": [],\n        \"isolation_forest\": []\n    }\n    \n    X_numpy = features_df.to_numpy()\n    \n    # Pre-load thresholds from predict.py for raw score calculation\n    AE_THRESHOLD = predict.AE_THRESHOLD\n    ISO_THRESHOLD = predict.ISO_THRESHOLD\n    \n    print(\"Running inference...\")\n    for i in tqdm(range(total_rows)):\n        raw_sample = X_numpy[i].reshape(1, -1)\n        \n        # 1. Unsupervised Models (Getting Raw Scores for ROC AUC)\n        # Replicating predict.py logic to get scores\n        scaled_unsupervised = predict.scale_unsupervised(raw_sample)\n        \n        # Autoencoder Score\n        X_tensor = predict.torch.tensor(scaled_unsupervised, dtype=predict.torch.float32)\n        with predict.torch.no_grad():\n            reconstructed = predict.AE_MODEL(X_tensor)\n            sq_errors = (X_tensor - reconstructed) ** 2\n            mse = predict.torch.mean(sq_errors, dim=1)\n            max_err = predict.torch.max(sq_errors, dim=1).values\n            ae_score = 0.5 * (mse + max_err).item()\n        ae_flag = 1 if ae_score > AE_THRESHOLD else 0\n        \n        # Isolation Forest Score\n        iso_score = predict.ISO_FOREST.decision_function(scaled_unsupervised)[0]\n        # IF decision_function: lower is more anomalous. For ROC AUC we want higher = more anomalous\n        # so we use -score\n        iso_auc_score = -iso_score \n        iso_flag = 1 if iso_score < ISO_THRESHOLD else 0\n        \n        # 2. Supervised Models\n        lgbm_pred, _ = predict._predict_lightgbm(raw_sample)\n        xgb_pred, _ = predict._predict_xgboost(raw_sample)\n        ffnn_pred, _ = predict._predict_ffnn(raw_sample)\n        logreg_pred, _ = predict._predict_logreg(raw_sample)\n        \n        # 3. Hybrid Pipeline Logic\n        pipeline_pred = lgbm_pred if (ae_flag == 1 or iso_flag == 1) else 0\n            \n        # Store predictions\n        preds[\"autoencoder\"].append(ae_flag)\n        preds[\"isolation_forest\"].append(iso_flag)\n        preds[\"logreg\"].append(logreg_pred)\n        preds[\"lightgbm\"].append(lgbm_pred)\n        preds[\"xgboost\"].append(xgb_pred)\n        preds[\"ffnn\"].append(ffnn_pred)\n        preds[\"pipeline\"].append(pipeline_pred)\n        \n        # Store scores for AUC\n        scores[\"autoencoder\"].append(ae_score)\n        scores[\"isolation_forest\"].append(iso_auc_score)\n\n    # Define model categories for reporting\n    multiclass_models = [\"lightgbm\", \"xgboost\", \"ffnn\", \"pipeline\"]\n    binary_models = [\"autoencoder\", \"isolation_forest\", \"logreg\"]\n    \n    # CICIDS2018 subset labels\n    PRESENT_LABELS = [0, 1, 2, 3, 4]\n    from sklearn.metrics import roc_auc_score\n\n    # Generate Reports\n    for model_name, y_pred in preds.items():\n        print(f\"\\nGenerating report for: {model_name}\")\n        \n        target = y_true if model_name in multiclass_models else y_true_binary\n        labels = PRESENT_LABELS if model_name in multiclass_models else [0, 1]\n        \n        report = classification_report(target, y_pred, labels=labels)\n        cm = confusion_matrix(target, y_pred, labels=labels)\n        \n        # Save text report\n        report_file = os.path.join(output_dir, f\"{model_name}_report.txt\")\n        with open(report_file, \"w\") as f:\n            f.write(f\"=== {model_name.upper()} CROSS-DATASET VALIDATION ===\\n\")\n            if model_name in scores:\n                auc = roc_auc_score(y_true_binary, scores[model_name])\n                f.write(f\"ROC AUC SCORE: {auc:.4f}\\n\\n\")\n            f.write(report)\n            f.write(\"\\n\\n=== CONFUSION MATRIX ===\\n\")\n            f.write(str(cm))\n            \n        # Save Confusion Matrix Plot\n        plt.figure(figsize=(10, 8))\n        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n                    xticklabels=labels, yticklabels=labels)\n        title = f\"{model_name.replace('_', ' ').title()} CM\"\n        if model_name in scores:\n            title += f\" (AUC: {auc:.3f})\"\n        plt.title(f\"{title}\\n(CICIDS2018 Cross-Validation)\")\n        plt.xlabel(\"Predicted\")\n        plt.ylabel(\"Actual\")\n        plt.savefig(os.path.join(output_dir, f\"{model_name}_cm.png\"), dpi=300)\n        plt.close()\n\n    print(f\"\\nAll cross-dataset validation results saved to '{output_dir}/'\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\stats_cicds2018.py",
                    "filename": "stats_cicds2018.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 14,
                    "end_line": 142,
                    "symbol": "evaluate_cross_dataset",
                    "chunk_idx": 1,
                    "size": 5069,
                    "_id": "1e60ce24-bb92-560c-a124-ecb1ac71dabb",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`\n- `POST /predict/autoencoder`\n- `POST /predict/isolationForest`\n- `POST /predict/xgboost`  \n---  \n### WebSocket Streaming\n`WS /intrusiondetection/ws/stream`\nStreams the dataset in batches of 100 rows with real-time statistics.  \n**Initialization Message**:\nAfter connecting, send the following JSON:\n```json\n{\n\"command\": \"start\",\n\"token\": \"your_secure_token_here\",\n\"start_at\": 0\n}\n```  \n**Final Summary Message**:\nAt the end of the stream, the server sends a summary containing final statistics and average latencies:\n```json\n{\n\"type\": \"summary\",\n\"status\": \"Stream Complete\",\n\"statistics\": {\n\"accuracy\": 0.85,\n\"total_processed\": 1000,\n\"correct_predictions\": 850,\n\"actual_counts\": {\"0\": 100, \"1\": 750, ...},\n\"predicted_counts\": {\"0\": 120, \"1\": 730, ...},\n\"average_latencies\": {\n\"autoencoder\": 0.000123,\n\"isolation_forest\": 0.000045,\n\"ffnn\": 0.000456,\n\"lightgbm\": 0.000789,\n\"logreg\": 0.000012,\n\"xgboost\": 0.000890,",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 5,
                    "size": 987,
                    "_id": "28326c1c-8329-5ba1-adda-3be25637f266",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "async def websocket_stream(websocket: WebSocket):\n    await websocket.accept()\n    try:\n        # Expected JSON: {\"command\": \"start\", \"start_at\": 0}\n        initial_data = await websocket.receive_json()\n        \n        if initial_data.get(\"command\") == \"start\":\n            # Token Check\n            if initial_data.get(\"token\") != API_TOKEN:\n                await websocket.send_json({\"error\": \"Unauthorized\"})\n                await websocket.close(code=1008)\n                return\n            \n            await websocket.send_json({\"status\": \"Authentication Successful\", \"message\": \"Stream starting...\"})\n                \n            start_idx = initial_data.get(\"start_at\", 0)\n            batch_size = 100\n            total_rows = len_df()\n            \n            # Statistics tracking\n            stats = {\n                \"total_processed\": 0,\n                \"correct_predictions\": 0,\n                \"actual_counts\": {},\n                \"predicted_counts\": {},\n                \"total_latencies\": {\n                    \"autoencoder\": 0.0,\n                    \"isolation_forest\": 0.0,\n                    \"ffnn\": 0.0,\n                    \"lightgbm\": 0.0,\n                    \"logreg\": 0.0,\n                    \"xgboost\": 0.0,\n                    \"pipeline\": 0.0\n                },\n                \"latency_counts\": {\n                    \"autoencoder\": 0,\n                    \"isolation_forest\": 0,\n                    \"ffnn\": 0,\n                    \"lightgbm\": 0,\n                    \"logreg\": 0,\n                    \"xgboost\": 0,\n                    \"pipeline\": 0\n                }\n            }\n            \n            for i in range(start_idx, total_rows, batch_size):\n                batch_results = []\n                end_idx = min(i + batch_size, total_rows)\n\n                loop = asyncio.get_event_loop()\n                for idx in range(i, end_idx):\n                    result = await loop.run_in_executor(None,predict.predict_attack_by_idx,idx)\n                    batch_results.append(result)\n                    \n                    # Update Statistics\n                    actual = str(result[\"target_class\"])\n                    # Use LightGBM prediction for accuracy tracking\n                    predicted = str(result.get(\"supervised\", {}).get(\"lightgbm\", 0)) if result[\"status\"] == \"Attack Detected\" else \"0\"\n                    \n                    stats[\"total_processed\"] += 1\n                    if actual == predicted:\n                        stats[\"correct_predictions\"] += 1\n                    \n                    stats[\"actual_counts\"][actual] = stats[\"actual_counts\"].get(actual, 0) + 1\n                    stats[\"predicted_counts\"][predicted] = stats[\"predicted_counts\"].get(predicted, 0) + 1\n\n                    # Update Latencies\n                    res_lats = result.get(\"latencies\", {})\n                    for model, lat in res_lats.items():\n                        if model in stats[\"total_latencies\"]:\n                            stats[\"total_latencies\"][model] += lat\n                            stats[\"latency_counts\"][model] += 1\n                    \n                    stats[\"total_latencies\"][\"pipeline\"] += result.get(\"total_detection_time\", 0)\n                    stats[\"latency_counts\"][\"pipeline\"] += 1\n                \n                # Calculate current accuracy for this snapshot\n                current_acc = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n                \n                # Send the batch with real-time stats\n                await websocket.send_json({\n                    \"type\": \"batch\",\n                    \"batch_start\": i,\n                    \"batch_end\": end_idx,\n                    \"data\": batch_results,\n                    \"current_statistics\": {\n                        \"accuracy\": round(current_acc, 4),\n                        \"total_processed\": stats[\"total_processed\"],\n                        \"correct_predictions\": stats[\"correct_predictions\"]\n                    }\n                })\n                \n                await asyncio.sleep(0.01)\n            \n            # Send Final Statistics\n            accuracy = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n            \n            # Calculate Average Latencies\n            avg_latencies = {\n                model: round(stats[\"total_latencies\"][model] / stats[\"latency_counts\"][model], 6)\n                if stats[\"latency_counts\"][model] > 0 else 0\n                for model in stats[\"total_latencies\"]\n            }\n\n            await websocket.send_json({\n                \"type\": \"summary\",\n                \"status\": \"Stream Complete\",\n                \"statistics\": {\n                    \"accuracy\": round(accuracy, 4),\n                    \"total_processed\": stats[\"total_processed\"],\n                    \"correct_predictions\": stats[\"correct_predictions\"],\n                    \"actual_counts\": stats[\"actual_counts\"],\n                    \"predicted_counts\": stats[\"predicted_counts\"],\n                    \"average_latencies\": avg_latencies\n                }\n            })\n            \n            # Close connection after finishing the task\n            await websocket.close(code=1000)\n                \n    except WebSocketDisconnect:\n        print(f\"WebSocket client disconnected.\")\n    except Exception as e:\n        print(f\"WebSocket error: {str(e)}\")\n        await websocket.close(code=1011)",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 191,
                    "end_line": 315,
                    "symbol": "websocket_stream",
                    "chunk_idx": 15,
                    "size": 5449,
                    "_id": "4d64eb89-57c0-5ee0-91e1-1073db67be4d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Hierarchical ML Pipeline**: Combines Unsupervised Anomaly Detection (Autoencoders, Isolation Forests) with Supervised Classification (LightGBM, XGBoost, FFNN).\n- **Real-time Inference**: Optimized for low-latency network flow analysis.\n- **WebSocket Streaming**: Stream and evaluate massive datasets with live accuracy telemetry.\n- **Secure by Design**: Token-based authentication and restricted CORS policies.\n- **Containerized**: Ready for deployment via Docker and Docker Compose.\n- **Detailed Analytics**: Built-in tools for generating confusion matrices and classification reports.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Key Features",
                    "symbol": "Key Features",
                    "chunk_idx": 2,
                    "size": 596,
                    "_id": "2f101085-ba79-5828-8cac-b2324f51d4c6",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "| File / Directory | Description |\n| :--- | :--- |\n| `router.py` | Main FastAPI application, defines HTTP routes and WebSocket logic. |\n| `predict.py` | Model loading (PyTorch, Joblib) and inference logic. |\n| `utils.py` | Data loading (Polars), scaling (MinMax/Standard), and preprocessing. |\n| `pcap_to_cicids.py` | Logic to convert raw PCAP files into 78-feature CICIDS datasets. |\n| `stats.py` | Evaluation script to generate confusion matrices and performance reports. |\n| `cors.py` | Middleware configuration for secure cross-origin requests. |\n| `models/` | Serialized ML models (`.pt`, `.pth`, `.joblib`, `.npy`). |\n| `scalers/` | Transformation models for data normalization (PCA, Scalers). |\n| `dockerfile` | Containerization configuration. |  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "Project Structure",
                    "symbol": "Project Structure",
                    "chunk_idx": 3,
                    "size": 758,
                    "_id": "46d8cdf6-df59-5fb5-ba00-8619b8275819",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`\n- `POST /predict/autoencoder`\n- `POST /predict/isolationForest`\n- `POST /predict/xgboost`  \n---  \n### WebSocket Streaming\n`WS /intrusiondetection/ws/stream`\nStreams the dataset in batches of 100 rows with real-time statistics.  \n**Initialization Message**:\nAfter connecting, send the following JSON:\n```json\n{\n\"command\": \"start\",\n\"token\": \"your_secure_token_here\",\n\"start_at\": 0\n}\n```  \n**Final Summary Message**:\nAt the end of the stream, the server sends a summary containing final statistics and average latencies:\n```json\n{\n\"type\": \"summary\",\n\"status\": \"Stream Complete\",\n\"statistics\": {\n\"accuracy\": 0.85,\n\"total_processed\": 1000,\n\"correct_predictions\": 850,\n\"actual_counts\": {\"0\": 100, \"1\": 750, ...},\n\"predicted_counts\": {\"0\": 120, \"1\": 730, ...},\n\"average_latencies\": {\n\"autoencoder\": 0.000123,\n\"isolation_forest\": 0.000045,\n\"ffnn\": 0.000456,\n\"lightgbm\": 0.000789,\n\"logreg\": 0.000012,\n\"xgboost\": 0.000890,",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 5,
                    "size": 987,
                    "_id": "28326c1c-8329-5ba1-adda-3be25637f266",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence\n- **Model Architecture**: CRNN produces correct output shapes (64\u00d7batch\u00d763) with H=60, W=256\n- **Data Loading**: Proper image preprocessing and CTC batching\n- **Full CAPTCHA Recognition**: Model now recognizes complete CAPTCHA sequences\n- **Inference Pipeline**: Complete inference script with visualization and accuracy metrics\n- **Early Stopping**: Enhanced early stopping prevents overfitting automatically\n- **High Accuracy**: 75-100% overall accuracy, 25/26+ character accuracy (96%+)  \n### \ud83c\udfaf Training Status\n- **Current**: Epoch 8, excellent convergence achieved\n- **Best Model**: Validation loss 0.1782, early stopping working perfectly\n- **Performance**: 75-100% accuracy on fresh CAPTCHAs (varies by run)  \n### \ud83d\udcca Training Results\n![Training Losses](Metrics/training_losses.png)\n![Loss Comparison](Metrics/loss_comparison.png)  \n**Key Insights:**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 4,
                    "size": 953,
                    "_id": "594be5fe-581c-57f0-b467-0938c58aa712",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Environment Setup\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```  \n### 2. Generate Training Dataset\n```bash\ncd src\npython data.py\n```\nThis creates 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with proper train/val/test splits.  \n### 3. Start Training\n```bash\npython train.py\n```\nThis starts the full training pipeline with automatic metrics generation.  \n### 4. Monitor Progress\nTraining will show:\n- Real-time loss and prediction samples\n- Automatic plot generation in `Metrics/` folder\n- Comprehensive training logs and summaries",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\ude80 Quick Start",
                    "symbol": "\ud83d\ude80 Quick Start",
                    "chunk_idx": 7,
                    "size": 721,
                    "_id": "3b357f42-2155-5453-a29c-795d0e1c9c09",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 Completed Components\n- **Dataset Generation**: Synthetic CAPTCHA creation with train/val/test splits (8k train, 1k val)\n- **Configuration**: Centralized config with image dimensions and training parameters\n- **Vocabulary System**: Character encoding/decoding with CTC blank token support (63 classes)\n- **CTC Collate Function**: Proper batching for variable-length sequences\n- **CTC Decoding**: Greedy decode for inference\n- **PyTorch Dataset Class**: Image loading and preprocessing with proper cv2 resizing\n- **CRNN Model**: CNN encoder + BiLSTM + LayerNorm + linear output (working!)\n- **Training Loop**: Complete epoch-based training pipeline with validation\n- **Metrics & Plotting**: Training/validation loss tracking with beautiful visualizations\n- **Debugging Tools**: Comprehensive logging of logits, predictions, and model health  \n### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 3,
                    "size": 945,
                    "_id": "cc52b2b4-6738-5973-9c50-29fc8882ca66",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "# User Repository Map\n\nThis document maps all repositories, folders, and files in the knowledge base.\nUse this to understand the high-level structure of the portfolio.\n\n## [CaptchaOCR]\n```text\n\u251c\u2500\u2500 checkpoints\n\u251c\u2500\u2500 Metrics\n\u2502   \u251c\u2500\u2500 .gitkeep\n\u2502   \u2514\u2500\u2500 training_metrics.txt\n\u251c\u2500\u2500 src\n\u2502   \u251c\u2500\u2500 captcha_dataset.py\n\u2502   \u251c\u2500\u2500 collate.py\n\u2502   \u251c\u2500\u2500 config.py\n\u2502   \u251c\u2500\u2500 data.py\n\u2502   \u251c\u2500\u2500 generateCaptcha.py\n\u2502   \u251c\u2500\u2500 model_crnn.py\n\u2502   \u251c\u2500\u2500 plotting.py\n\u2502   \u251c\u2500\u2500 test.py\n\u2502   \u2514\u2500\u2500 vocab.py\n\u251c\u2500\u2500 .gitattributes\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 app.py\n\u251c\u2500\u2500 inference.py\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 requirements.txt\n\u251c\u2500\u2500 train.py\n\u2514\u2500\u2500 train_sanity.py\n```\n\n## [HermesGPT]\n```text\n\u251c\u2500\u2500 hermesgpt.py\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 README.md\n\u2514\u2500\u2500 requirements.txt\n```\n\n## [IntrusionBackend]\n```text\n\u251c\u2500\u2500 cross_dataset_results\n\u2502   \u251c\u2500\u2500 autoencoder_report.txt\n\u2502   \u251c\u2500\u2500 ffnn_report.txt\n\u2502   \u251c\u2500\u2500 isolation_forest_report.txt\n\u2502   \u251c\u2500\u2500 lightgbm_report.txt\n\u2502   \u251c\u2500\u2500 logreg_report.txt\n\u2502   \u251c\u2500\u2500 pipeline_report.txt\n\u2502   \u2514\u2500\u2500 xgboost_report.txt\n\u251c\u2500\u2500 models\n\u2502   \u251c\u2500\u2500 logreg_b.npy\n\u2502   \u2514\u2500\u2500 logreg_W.npy\n\u251c\u2500\u2500 scalers\n\u251c\u2500\u2500 .dockerignore\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 confusion_matrix.txt\n\u251c\u2500\u2500 cors.py\n\u251c\u2500\u2500 docker-compose.yml\n\u251c\u2500\u2500 dockerfile\n\u251c\u2500\u2500 documentation.md\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 pcap_to_cicids.py\n\u251c\u2500\u2500 predict.py\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 requirements.txt\n\u251c\u2500\u2500 router.py\n\u251c\u2500\u2500 stats.py\n\u251c\u2500\u2500 stats_cicds2018.py\n\u251c\u2500\u2500 test.py\n\u2514\u2500\u2500 utils.py\n```\n",
                "metadata": {
                    "repo": "global",
                    "path": "portfolio_graph",
                    "language": "markdown",
                    "type": "global_graph",
                    "_id": "fd1e2143-57fe-5730-96e7-c5347468f47c",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "annotated-doc==0.0.4\nannotated-types==0.7.0\nanyio==4.12.0\nclick==8.3.1\ncontourpy==1.3.3\ncramjam==2.11.0\ncycler==0.12.1\ndotenv==0.9.9\nfastapi==0.124.4\nfastparquet==2024.11.0\nfilelock==3.20.0\nfonttools==4.62.1\nfsspec==2025.12.0\nh11==0.16.0\nidna==3.11\nJinja2==3.1.6\njoblib==1.5.2\nkiwisolver==1.5.0\nlightgbm==4.6.0\nMarkupSafe==2.1.5\nmatplotlib==3.10.9\nmpmath==1.3.0\nnetworkx==3.6.1\nnumpy==2.3.5\npackaging==25.0\npandas==2.3.3\npillow==12.0.0\npolars==1.40.1\npolars-runtime-32==1.40.1\npyarrow==22.0.0\npydantic==2.12.5\npydantic_core==2.41.5\npyparsing==3.3.2\npython-dateutil==2.9.0.post0\npython-dotenv==1.2.1\npytz==2025.2\nscikit-learn==1.8.0\nscipy==1.16.3\nseaborn==0.13.2\nsetuptools==70.2.0\nsix==1.17.0\nstarlette==0.50.0\nsympy==1.14.0\nthreadpoolctl==3.6.0\ntorch\ntorchaudio\ntorchvision\ntqdm==4.67.3\ntyping-inspection==0.4.2\ntyping_extensions==4.15.0\ntzdata==2025.2\nuvicorn==0.38.0\nwebsockets==16.0\nxgboost==3.2.0\n",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/requirements.txt",
                    "filename": "requirements.txt",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 902,
                    "_id": "1e3a1dd7-2519-5be7-a52a-7cb7e21a3b0c",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- [CTC Paper](https://www.cs.toronto.edu/~graves/icml_2006.pdf)\n- [CRNN Architecture](https://arxiv.org/abs/1507.05717)  \nThis project is for educational purposes. Feel free to use and modify as needed.  \n---  \n**Happy coding! \ud83d\ude80**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcda Resources",
                    "symbol": "\ud83d\udcda Resources",
                    "chunk_idx": 17,
                    "size": 230,
                    "_id": "9f806412-10e4-5a7b-be49-08175ab1d285",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "The project follows a modular architecture designed for low-latency inference and high throughput.  \n```mermaid\ngraph TD\nA[Network Traffic / PCAP] -->|Feature Extraction| B(CICIDS Features)\nB --> C{Hybrid Pipeline}\nC --> D[Unsupervised Layer]\nD -->|Anomalies Flagged| E[Supervised Layer]\nE -->|Final Classification| F[Actionable Insight]\nD -->|Benign| G[Safe Traffic]\n```  \n### Machine Learning Pipeline\nThe core of this project is a **Hierarchical Detection Strategy**:  \n1.  **Unsupervised Layer (The Flaggers)**:\n- **Autoencoder**: Reconstructs input data; high reconstruction error indicates an anomaly.\n- **Isolation Forest**: Detects anomalies by isolating observations in feature space.\n- *Logic*: If either model flags the traffic, it proceeds to the next stage.  \n2.  **Supervised Layer (The Judges)**:\n- **LightGBM (Final Veto)**: A gradient boosting framework that provides the final classification.",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "System Architecture",
                    "symbol": "System Architecture",
                    "chunk_idx": 1,
                    "size": 910,
                    "_id": "755fce9d-1447-54ea-9959-5a3136e676ba",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "class FlowTable:\n    def __init__(self):\n        self._flows: Dict[FlowKey, FlowStats] = {}\n        self._completed: List[Dict] = []\n\n    def _key(self, pkt: Packet) -> Tuple[FlowKey, bool]:\n        \"\"\"Return (canonical_key, is_forward).\"\"\"\n        k_fwd = (pkt.src_ip, pkt.dst_ip, pkt.src_port, pkt.dst_port, pkt.proto)\n        k_bwd = (pkt.dst_ip, pkt.src_ip, pkt.dst_port, pkt.src_port, pkt.proto)\n        if k_fwd in self._flows:\n            return k_fwd, True\n        if k_bwd in self._flows:\n            return k_bwd, False\n        return k_fwd, True   # new flow\n\n    def _update_active_idle(self, fs: FlowStats, ts: int):\n        ACTIVE_THRESHOLD = 1 * 1_000_000   # 1-second gap = idle\n        if fs.prev_last_ts > 0:\n            gap = ts - fs.prev_last_ts\n            if gap > ACTIVE_THRESHOLD:\n                active_dur = fs.prev_last_ts - fs.last_active_start\n                if active_dur > 0:\n                    fs.active_times.append(active_dur)\n                fs.idle_times.append(gap)\n                fs.last_active_start = ts\n        fs.prev_last_ts = ts\n\n    def process(self, pkt: Packet, label: str = \"BENIGN\"):\n        key, is_fwd = self._key(pkt)\n\n        if key not in self._flows:\n            fs = FlowStats(\n                src_ip=pkt.src_ip, dst_ip=pkt.dst_ip,\n                src_port=pkt.src_port, dst_port=pkt.dst_port,\n                proto=pkt.proto,\n                start_ts=pkt.ts_us, last_ts=pkt.ts_us,\n                last_active_start=pkt.ts_us, prev_last_ts=pkt.ts_us,\n            )\n            self._flows[key] = fs\n        else:\n            fs = self._flows[key]\n\n        # timeout check\n        if pkt.ts_us - fs.last_ts > FLOW_TIMEOUT_US:\n            self._complete(key, label)\n            fs = FlowStats(\n                src_ip=pkt.src_ip, dst_ip=pkt.dst_ip,\n                src_port=pkt.src_port, dst_port=pkt.dst_port,\n                proto=pkt.proto,\n                start_ts=pkt.ts_us, last_ts=pkt.ts_us,\n                last_active_start=pkt.ts_us, prev_last_ts=pkt.ts_us,\n            )\n            self._flows[key] = fs\n            is_fwd = True\n\n        # IAT\n        if fs.last_ts > 0:\n            iat = pkt.ts_us - fs.last_ts\n            fs.flow_iats.append(iat)\n            if is_fwd:\n                if fs.fwd_pkts:\n                    fs.fwd_iats.append(iat)\n            else:\n                if fs.bwd_pkts:\n                    fs.bwd_iats.append(iat)\n\n        self._update_active_idle(fs, pkt.ts_us)\n        fs.last_ts = pkt.ts_us\n\n        # accumulate\n        if is_fwd:\n            fs.fwd_pkts.append(pkt.ip_len)\n        else:\n            fs.bwd_pkts.append(pkt.ip_len)\n\n        # TCP flags\n        if pkt.proto == 6:\n            f = pkt.tcp_flags\n            if is_fwd:\n                fs.fwd_fin += (f >> 0) & 1\n                fs.fwd_syn += (f >> 1) & 1\n                fs.fwd_rst += (f >> 2) & 1\n                fs.fwd_psh += (f >> 3) & 1\n                fs.fwd_ack += (f >> 4) & 1\n                fs.fwd_urg += (f >> 5) & 1\n            else:\n                fs.bwd_fin += (f >> 0) & 1\n                fs.bwd_syn += (f >> 1) & 1\n                fs.bwd_rst += (f >> 2) & 1\n                fs.bwd_psh += (f >> 3) & 1\n                fs.bwd_ack += (f >> 4) & 1\n                fs.bwd_urg += (f >> 5) & 1\n\n        # TCP FIN/RST \u2192 close flow\n        if pkt.proto == 6 and (pkt.tcp_flags & 0x01 or pkt.tcp_flags & 0x04):\n            self._complete(key, label)\n\n    def _complete(self, key: FlowKey, label: str):\n        fs = self._flows.pop(key, None)\n        if fs and (fs.fwd_pkts or fs.bwd_pkts):\n            # finalise active time\n            if fs.prev_last_ts > fs.last_active_start:\n                fs.active_times.append(fs.prev_last_ts - fs.last_active_start)\n            self._completed.append(_flow_to_row(fs, label))\n\n    def flush(self, label: str = \"BENIGN\"):\n        for key in list(self._flows.keys()):\n            self._complete(key, label)\n\n    def get_rows(self) -> List[Dict]:\n        return self._completed",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\pcap_to_cicids.py",
                    "filename": "pcap_to_cicids.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "class",
                    "start_line": 328,
                    "end_line": 438,
                    "symbol": "FlowTable",
                    "chunk_idx": 8,
                    "size": 3987,
                    "_id": "8a7f61b3-8beb-5957-825b-0cc97b971fe7",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- \ud83d\udcc4 **Resume Parsing**: Loads and processes resume data for personalized email generation.\n- \ud83e\udd16 **AI-Powered Emails**: Uses Gemini AI to generate tailored cold emails.\n- \ud83d\udcec **Automated Email Sending**: Sends emails via Gmail API with attachments.\n- \u2705 **Email Verification**: Uses SMTP and Maileroo API to validate emails before sending.\n- \ud83d\uddc4 **Database Management**: Stores recruiter data in PostgreSQL and tracks outreach progress.\n- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Features",
                    "symbol": "Features",
                    "chunk_idx": 1,
                    "size": 529,
                    "_id": "2b1ec077-3dbf-5a35-8275-b58b0b6597fd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "HermesGPT is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities. It integrates AI-generated personalized cold emails, database management, email verification, and automated sending using Gmail API.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "None",
                    "symbol": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "chunk_idx": 0,
                    "size": 271,
                    "_id": "8b6916d8-be29-5c9f-9c4a-5a0be949d971",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def websocket_stream(websocket: WebSocket):\n    await websocket.accept()\n    try:\n        # Expected JSON: {\"command\": \"start\", \"start_at\": 0}\n        initial_data = await websocket.receive_json()\n        \n        if initial_data.get(\"command\") == \"start\":\n            # Token Check\n            if initial_data.get(\"token\") != API_TOKEN:\n                await websocket.send_json({\"error\": \"Unauthorized\"})\n                await websocket.close(code=1008)\n                return\n            \n            await websocket.send_json({\"status\": \"Authentication Successful\", \"message\": \"Stream starting...\"})\n                \n            start_idx = initial_data.get(\"start_at\", 0)\n            batch_size = 100\n            total_rows = len_df()\n            \n            # Statistics tracking\n            stats = {\n                \"total_processed\": 0,\n                \"correct_predictions\": 0,\n                \"actual_counts\": {},\n                \"predicted_counts\": {},\n                \"total_latencies\": {\n                    \"autoencoder\": 0.0,\n                    \"isolation_forest\": 0.0,\n                    \"ffnn\": 0.0,\n                    \"lightgbm\": 0.0,\n                    \"logreg\": 0.0,\n                    \"xgboost\": 0.0,\n                    \"pipeline\": 0.0\n                },\n                \"latency_counts\": {\n                    \"autoencoder\": 0,\n                    \"isolation_forest\": 0,\n                    \"ffnn\": 0,\n                    \"lightgbm\": 0,\n                    \"logreg\": 0,\n                    \"xgboost\": 0,\n                    \"pipeline\": 0\n                }\n            }\n            \n            for i in range(start_idx, total_rows, batch_size):\n                batch_results = []\n                end_idx = min(i + batch_size, total_rows)\n\n                loop = asyncio.get_event_loop()\n                for idx in range(i, end_idx):\n                    result = await loop.run_in_executor(None,predict.predict_attack_by_idx,idx)\n                    batch_results.append(result)\n                    \n                    # Update Statistics\n                    actual = str(result[\"target_class\"])\n                    # Use LightGBM prediction for accuracy tracking\n                    predicted = str(result.get(\"supervised\", {}).get(\"lightgbm\", 0)) if result[\"status\"] == \"Attack Detected\" else \"0\"\n                    \n                    stats[\"total_processed\"] += 1\n                    if actual == predicted:\n                        stats[\"correct_predictions\"] += 1\n                    \n                    stats[\"actual_counts\"][actual] = stats[\"actual_counts\"].get(actual, 0) + 1\n                    stats[\"predicted_counts\"][predicted] = stats[\"predicted_counts\"].get(predicted, 0) + 1\n\n                    # Update Latencies\n                    res_lats = result.get(\"latencies\", {})\n                    for model, lat in res_lats.items():\n                        if model in stats[\"total_latencies\"]:\n                            stats[\"total_latencies\"][model] += lat\n                            stats[\"latency_counts\"][model] += 1\n                    \n                    stats[\"total_latencies\"][\"pipeline\"] += result.get(\"total_detection_time\", 0)\n                    stats[\"latency_counts\"][\"pipeline\"] += 1\n                \n                # Calculate current accuracy for this snapshot\n                current_acc = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n                \n                # Send the batch with real-time stats\n                await websocket.send_json({\n                    \"type\": \"batch\",\n                    \"batch_start\": i,\n                    \"batch_end\": end_idx,\n                    \"data\": batch_results,\n                    \"current_statistics\": {\n                        \"accuracy\": round(current_acc, 4),\n                        \"total_processed\": stats[\"total_processed\"],\n                        \"correct_predictions\": stats[\"correct_predictions\"]\n                    }\n                })\n                \n                await asyncio.sleep(0.01)\n            \n            # Send Final Statistics\n            accuracy = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n            \n            # Calculate Average Latencies\n            avg_latencies = {\n                model: round(stats[\"total_latencies\"][model] / stats[\"latency_counts\"][model], 6)\n                if stats[\"latency_counts\"][model] > 0 else 0\n                for model in stats[\"total_latencies\"]\n            }\n\n            await websocket.send_json({\n                \"type\": \"summary\",\n                \"status\": \"Stream Complete\",\n                \"statistics\": {\n                    \"accuracy\": round(accuracy, 4),\n                    \"total_processed\": stats[\"total_processed\"],\n                    \"correct_predictions\": stats[\"correct_predictions\"],\n                    \"actual_counts\": stats[\"actual_counts\"],\n                    \"predicted_counts\": stats[\"predicted_counts\"],\n                    \"average_latencies\": avg_latencies\n                }\n            })\n            \n            # Close connection after finishing the task\n            await websocket.close(code=1000)\n                \n    except WebSocketDisconnect:\n        print(f\"WebSocket client disconnected.\")\n    except Exception as e:\n        print(f\"WebSocket error: {str(e)}\")\n        await websocket.close(code=1011)",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 191,
                    "end_line": 315,
                    "symbol": "websocket_stream",
                    "chunk_idx": 15,
                    "size": 5449,
                    "_id": "4d64eb89-57c0-5ee0-91e1-1073db67be4d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "async def websocket_stream(websocket: WebSocket):\n    await websocket.accept()\n    try:\n        # Expected JSON: {\"command\": \"start\", \"start_at\": 0}\n        initial_data = await websocket.receive_json()\n        \n        if initial_data.get(\"command\") == \"start\":\n            # Token Check\n            if initial_data.get(\"token\") != API_TOKEN:\n                await websocket.send_json({\"error\": \"Unauthorized\"})\n                await websocket.close(code=1008)\n                return\n            \n            await websocket.send_json({\"status\": \"Authentication Successful\", \"message\": \"Stream starting...\"})\n                \n            start_idx = initial_data.get(\"start_at\", 0)\n            batch_size = 100\n            total_rows = len_df()\n            \n            # Statistics tracking\n            stats = {\n                \"total_processed\": 0,\n                \"correct_predictions\": 0,\n                \"actual_counts\": {},\n                \"predicted_counts\": {},\n                \"total_latencies\": {\n                    \"autoencoder\": 0.0,\n                    \"isolation_forest\": 0.0,\n                    \"ffnn\": 0.0,\n                    \"lightgbm\": 0.0,\n                    \"logreg\": 0.0,\n                    \"xgboost\": 0.0,\n                    \"pipeline\": 0.0\n                },\n                \"latency_counts\": {\n                    \"autoencoder\": 0,\n                    \"isolation_forest\": 0,\n                    \"ffnn\": 0,\n                    \"lightgbm\": 0,\n                    \"logreg\": 0,\n                    \"xgboost\": 0,\n                    \"pipeline\": 0\n                }\n            }\n            \n            for i in range(start_idx, total_rows, batch_size):\n                batch_results = []\n                end_idx = min(i + batch_size, total_rows)\n\n                loop = asyncio.get_event_loop()\n                for idx in range(i, end_idx):\n                    result = await loop.run_in_executor(None,predict.predict_attack_by_idx,idx)\n                    batch_results.append(result)\n                    \n                    # Update Statistics\n                    actual = str(result[\"target_class\"])\n                    # Use LightGBM prediction for accuracy tracking\n                    predicted = str(result.get(\"supervised\", {}).get(\"lightgbm\", 0)) if result[\"status\"] == \"Attack Detected\" else \"0\"\n                    \n                    stats[\"total_processed\"] += 1\n                    if actual == predicted:\n                        stats[\"correct_predictions\"] += 1\n                    \n                    stats[\"actual_counts\"][actual] = stats[\"actual_counts\"].get(actual, 0) + 1\n                    stats[\"predicted_counts\"][predicted] = stats[\"predicted_counts\"].get(predicted, 0) + 1\n\n                    # Update Latencies\n                    res_lats = result.get(\"latencies\", {})\n                    for model, lat in res_lats.items():\n                        if model in stats[\"total_latencies\"]:\n                            stats[\"total_latencies\"][model] += lat\n                            stats[\"latency_counts\"][model] += 1\n                    \n                    stats[\"total_latencies\"][\"pipeline\"] += result.get(\"total_detection_time\", 0)\n                    stats[\"latency_counts\"][\"pipeline\"] += 1\n                \n                # Calculate current accuracy for this snapshot\n                current_acc = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n                \n                # Send the batch with real-time stats\n                await websocket.send_json({\n                    \"type\": \"batch\",\n                    \"batch_start\": i,\n                    \"batch_end\": end_idx,\n                    \"data\": batch_results,\n                    \"current_statistics\": {\n                        \"accuracy\": round(current_acc, 4),\n                        \"total_processed\": stats[\"total_processed\"],\n                        \"correct_predictions\": stats[\"correct_predictions\"]\n                    }\n                })\n                \n                await asyncio.sleep(0.01)\n            \n            # Send Final Statistics\n            accuracy = stats[\"correct_predictions\"] / stats[\"total_processed\"] if stats[\"total_processed\"] > 0 else 0\n            \n            # Calculate Average Latencies\n            avg_latencies = {\n                model: round(stats[\"total_latencies\"][model] / stats[\"latency_counts\"][model], 6)\n                if stats[\"latency_counts\"][model] > 0 else 0\n                for model in stats[\"total_latencies\"]\n            }\n\n            await websocket.send_json({\n                \"type\": \"summary\",\n                \"status\": \"Stream Complete\",\n                \"statistics\": {\n                    \"accuracy\": round(accuracy, 4),\n                    \"total_processed\": stats[\"total_processed\"],\n                    \"correct_predictions\": stats[\"correct_predictions\"],\n                    \"actual_counts\": stats[\"actual_counts\"],\n                    \"predicted_counts\": stats[\"predicted_counts\"],\n                    \"average_latencies\": avg_latencies\n                }\n            })\n            \n            # Close connection after finishing the task\n            await websocket.close(code=1000)\n                \n    except WebSocketDisconnect:\n        print(f\"WebSocket client disconnected.\")\n    except Exception as e:\n        print(f\"WebSocket error: {str(e)}\")\n        await websocket.close(code=1011)",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 191,
                    "end_line": 315,
                    "symbol": "websocket_stream",
                    "chunk_idx": 15,
                    "size": 5449,
                    "_id": "4d64eb89-57c0-5ee0-91e1-1073db67be4d",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`\n- `POST /predict/autoencoder`\n- `POST /predict/isolationForest`\n- `POST /predict/xgboost`  \n---  \n### WebSocket Streaming\n`WS /intrusiondetection/ws/stream`\nStreams the dataset in batches of 100 rows with real-time statistics.  \n**Initialization Message**:\nAfter connecting, send the following JSON:\n```json\n{\n\"command\": \"start\",\n\"token\": \"your_secure_token_here\",\n\"start_at\": 0\n}\n```  \n**Final Summary Message**:\nAt the end of the stream, the server sends a summary containing final statistics and average latencies:\n```json\n{\n\"type\": \"summary\",\n\"status\": \"Stream Complete\",\n\"statistics\": {\n\"accuracy\": 0.85,\n\"total_processed\": 1000,\n\"correct_predictions\": 850,\n\"actual_counts\": {\"0\": 100, \"1\": 750, ...},\n\"predicted_counts\": {\"0\": 120, \"1\": 730, ...},\n\"average_latencies\": {\n\"autoencoder\": 0.000123,\n\"isolation_forest\": 0.000045,\n\"ffnn\": 0.000456,\n\"lightgbm\": 0.000789,\n\"logreg\": 0.000012,\n\"xgboost\": 0.000890,",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 5,
                    "size": 987,
                    "_id": "28326c1c-8329-5ba1-adda-3be25637f266",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "HermesGPT is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities. It integrates AI-generated personalized cold emails, database management, email verification, and automated sending using Gmail API.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "None",
                    "symbol": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "chunk_idx": 0,
                    "size": 271,
                    "_id": "8b6916d8-be29-5c9f-9c4a-5a0be949d971",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Hierarchical ML Pipeline**: Combines Unsupervised Anomaly Detection (Autoencoders, Isolation Forests) with Supervised Classification (LightGBM, XGBoost, FFNN).\n- **Real-time Inference**: Optimized for low-latency network flow analysis.\n- **WebSocket Streaming**: Stream and evaluate massive datasets with live accuracy telemetry.\n- **Secure by Design**: Token-based authentication and restricted CORS policies.\n- **Containerized**: Ready for deployment via Docker and Docker Compose.\n- **Detailed Analytics**: Built-in tools for generating confusion matrices and classification reports.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Key Features",
                    "symbol": "Key Features",
                    "chunk_idx": 2,
                    "size": 596,
                    "_id": "2f101085-ba79-5828-8cac-b2324f51d4c6",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "class FlowTable:\n    def __init__(self):\n        self._flows: Dict[FlowKey, FlowStats] = {}\n        self._completed: List[Dict] = []\n\n    def _key(self, pkt: Packet) -> Tuple[FlowKey, bool]:\n        \"\"\"Return (canonical_key, is_forward).\"\"\"\n        k_fwd = (pkt.src_ip, pkt.dst_ip, pkt.src_port, pkt.dst_port, pkt.proto)\n        k_bwd = (pkt.dst_ip, pkt.src_ip, pkt.dst_port, pkt.src_port, pkt.proto)\n        if k_fwd in self._flows:\n            return k_fwd, True\n        if k_bwd in self._flows:\n            return k_bwd, False\n        return k_fwd, True   # new flow\n\n    def _update_active_idle(self, fs: FlowStats, ts: int):\n        ACTIVE_THRESHOLD = 1 * 1_000_000   # 1-second gap = idle\n        if fs.prev_last_ts > 0:\n            gap = ts - fs.prev_last_ts\n            if gap > ACTIVE_THRESHOLD:\n                active_dur = fs.prev_last_ts - fs.last_active_start\n                if active_dur > 0:\n                    fs.active_times.append(active_dur)\n                fs.idle_times.append(gap)\n                fs.last_active_start = ts\n        fs.prev_last_ts = ts\n\n    def process(self, pkt: Packet, label: str = \"BENIGN\"):\n        key, is_fwd = self._key(pkt)\n\n        if key not in self._flows:\n            fs = FlowStats(\n                src_ip=pkt.src_ip, dst_ip=pkt.dst_ip,\n                src_port=pkt.src_port, dst_port=pkt.dst_port,\n                proto=pkt.proto,\n                start_ts=pkt.ts_us, last_ts=pkt.ts_us,\n                last_active_start=pkt.ts_us, prev_last_ts=pkt.ts_us,\n            )\n            self._flows[key] = fs\n        else:\n            fs = self._flows[key]\n\n        # timeout check\n        if pkt.ts_us - fs.last_ts > FLOW_TIMEOUT_US:\n            self._complete(key, label)\n            fs = FlowStats(\n                src_ip=pkt.src_ip, dst_ip=pkt.dst_ip,\n                src_port=pkt.src_port, dst_port=pkt.dst_port,\n                proto=pkt.proto,\n                start_ts=pkt.ts_us, last_ts=pkt.ts_us,\n                last_active_start=pkt.ts_us, prev_last_ts=pkt.ts_us,\n            )\n            self._flows[key] = fs\n            is_fwd = True\n\n        # IAT\n        if fs.last_ts > 0:\n            iat = pkt.ts_us - fs.last_ts\n            fs.flow_iats.append(iat)\n            if is_fwd:\n                if fs.fwd_pkts:\n                    fs.fwd_iats.append(iat)\n            else:\n                if fs.bwd_pkts:\n                    fs.bwd_iats.append(iat)\n\n        self._update_active_idle(fs, pkt.ts_us)\n        fs.last_ts = pkt.ts_us\n\n        # accumulate\n        if is_fwd:\n            fs.fwd_pkts.append(pkt.ip_len)\n        else:\n            fs.bwd_pkts.append(pkt.ip_len)\n\n        # TCP flags\n        if pkt.proto == 6:\n            f = pkt.tcp_flags\n            if is_fwd:\n                fs.fwd_fin += (f >> 0) & 1\n                fs.fwd_syn += (f >> 1) & 1\n                fs.fwd_rst += (f >> 2) & 1\n                fs.fwd_psh += (f >> 3) & 1\n                fs.fwd_ack += (f >> 4) & 1\n                fs.fwd_urg += (f >> 5) & 1\n            else:\n                fs.bwd_fin += (f >> 0) & 1\n                fs.bwd_syn += (f >> 1) & 1\n                fs.bwd_rst += (f >> 2) & 1\n                fs.bwd_psh += (f >> 3) & 1\n                fs.bwd_ack += (f >> 4) & 1\n                fs.bwd_urg += (f >> 5) & 1\n\n        # TCP FIN/RST \u2192 close flow\n        if pkt.proto == 6 and (pkt.tcp_flags & 0x01 or pkt.tcp_flags & 0x04):\n            self._complete(key, label)\n\n    def _complete(self, key: FlowKey, label: str):\n        fs = self._flows.pop(key, None)\n        if fs and (fs.fwd_pkts or fs.bwd_pkts):\n            # finalise active time\n            if fs.prev_last_ts > fs.last_active_start:\n                fs.active_times.append(fs.prev_last_ts - fs.last_active_start)\n            self._completed.append(_flow_to_row(fs, label))\n\n    def flush(self, label: str = \"BENIGN\"):\n        for key in list(self._flows.keys()):\n            self._complete(key, label)\n\n    def get_rows(self) -> List[Dict]:\n        return self._completed",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\pcap_to_cicids.py",
                    "filename": "pcap_to_cicids.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "class",
                    "start_line": 328,
                    "end_line": 438,
                    "symbol": "FlowTable",
                    "chunk_idx": 8,
                    "size": 3987,
                    "_id": "8a7f61b3-8beb-5957-825b-0cc97b971fe7",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "For technical implementation details, model architectures, and full API specifications, please refer to our:  \n### [Detailed Documentation](./documentation.md)  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Deep Dive",
                    "symbol": "Deep Dive",
                    "chunk_idx": 4,
                    "size": 165,
                    "_id": "7a094734-5ac2-5143-96e1-283fed011c43",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Clone the Repository  \n```sh\ngit clone https://github.com/your-username/HermesGPT.git\ncd HermesGPT\n```  \n### 2. Install Dependencies  \nMake sure you have Python installed, then install the required packages:  \n```sh\npip install -r requirements.txt\n```  \n### 3. Configure Database  \nSet up a PostgreSQL database with the following schema:  \n```sql\nCREATE TABLE recruiters (\nemail TEXT PRIMARY KEY,\nrecruiter_name TEXT,\ncompany_name TEXT,\nrole TEXT,\ncontacted BOOLEAN DEFAULT FALSE\n);\n```  \n### 4. Set Up Gmail API  \n1. Enable the Gmail API from Google Cloud Console.\n2. Download `credentials.json` and place it in the project directory.\n3. Run authentication:  \n```sh\npython main.py\n```  \n### 5. API Keys  \n- **Gemini AI API**: Add your Gemini API key to the `API_KEY` variable.  \n### 6. Load Recruiter Data  \nPrepare a CSV file (`recruiters.csv`) with the following columns:  \n| Email | Name | Company | Title |\n|-------|------|---------|-------|",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Setup Instructions",
                    "symbol": "Setup Instructions",
                    "chunk_idx": 2,
                    "size": 953,
                    "_id": "c1147930-c01b-59e0-a7d4-b6330fbf4ec4",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This is a learning project! Feel free to:\n- Ask questions about implementation details\n- Experiment with different architectures\n- Improve the data generation or training pipeline",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83e\udd1d Contributing",
                    "symbol": "\ud83e\udd1d Contributing",
                    "chunk_idx": 16,
                    "size": 179,
                    "_id": "0bb57d4e-10c5-5bbe-83d6-74f9591fda94",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "The project follows a modular architecture designed for low-latency inference and high throughput.  \n```mermaid\ngraph TD\nA[Network Traffic / PCAP] -->|Feature Extraction| B(CICIDS Features)\nB --> C{Hybrid Pipeline}\nC --> D[Unsupervised Layer]\nD -->|Anomalies Flagged| E[Supervised Layer]\nE -->|Final Classification| F[Actionable Insight]\nD -->|Benign| G[Safe Traffic]\n```  \n### Machine Learning Pipeline\nThe core of this project is a **Hierarchical Detection Strategy**:  \n1.  **Unsupervised Layer (The Flaggers)**:\n- **Autoencoder**: Reconstructs input data; high reconstruction error indicates an anomaly.\n- **Isolation Forest**: Detects anomalies by isolating observations in feature space.\n- *Logic*: If either model flags the traffic, it proceeds to the next stage.  \n2.  **Supervised Layer (The Judges)**:\n- **LightGBM (Final Veto)**: A gradient boosting framework that provides the final classification.",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "System Architecture",
                    "symbol": "System Architecture",
                    "chunk_idx": 1,
                    "size": 910,
                    "_id": "755fce9d-1447-54ea-9959-5a3136e676ba",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Implement Dataset class** - Load and preprocess images\n2. **Build CRNN model** - CNN + BiLSTM architecture\n3. **Create training loop** - With validation and checkpoints\n4. **Add metrics** - CER and accuracy tracking\n5. **Test on small dataset** - Verify everything works\n6. **Scale to full dataset** - Train on Colab",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udee0\ufe0f Development Workflow",
                    "symbol": "\ud83d\udee0\ufe0f Development Workflow",
                    "chunk_idx": 15,
                    "size": 321,
                    "_id": "60bcb358-3110-5090-a80c-cf9343a2c6c2",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "from fastapi.middleware.cors import CORSMiddleware\nfrom fastapi import FastAPI",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 2,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 78,
                    "_id": "afba59f5-c68c-50fb-98b3-e3c232782271",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def configure_cors(app: FastAPI) -> None:\n    \"\"\"\n    Configure CORS middleware for the FastAPI application.\n    \n    Allows requests from specified origins with credentials support.\n    \"\"\"\n    # Define allowed origins\n    allowed_origins = [\n        \"https://mohakapoor.in\",\n        \"https://sisyphus.mohakapoor.in\",\n        \"http://mohakapoor.in\",\n        \"http://sisyphus.mohakapoor.in\",\n        \"http://localhost:8000\"\n    ]\n    \n    # Add CORS middleware\n    app.add_middleware(\n        CORSMiddleware,\n        allow_origins=allowed_origins,\n        allow_credentials=True,\n        allow_methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\", \"PATCH\"],\n        allow_headers=[\"*\"],\n        expose_headers=[\"*\"],\n        max_age=3600  # Cache preflight requests for 1 hour\n    )",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\cors.py",
                    "filename": "cors.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 5,
                    "end_line": 29,
                    "symbol": "configure_cors",
                    "chunk_idx": 1,
                    "size": 780,
                    "_id": "cdf88a69-08e6-5ddc-85da-893dcf5a25ce",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "Welcome to the **Intrusion Tracker Backend**, a high-performance network security monitoring system powered by FastAPI and a hierarchical machine learning pipeline. This system is designed to detect and classify network intrusions in real-time.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend - Project Documentation",
                    "chunk_idx": 0,
                    "size": 250,
                    "_id": "c66c7fb9-8127-51d3-80e8-e40321cbd828",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"IntrusionBackend\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"dev\",\n  \"current_commit_sha\": \"97eba2e1d8ec3a7da08c2e43a3f02d48b8b1f5a3\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"dev\"\n  ],\n  \"topics\": [\n    \"api\",\n    \"backend\",\n    \"fastapi\",\n    \"inference\",\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:11.546021+00:00\"\n}",
                "metadata": {
                    "repo": "IntrusionBackend",
                    "path": "knowledge_base/repos/IntrusionBackend/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 458,
                    "_id": "af0fef8b-51eb-58d9-90d6-6887810d9835",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "- \ud83d\udcc4 **Resume Parsing**: Loads and processes resume data for personalized email generation.\n- \ud83e\udd16 **AI-Powered Emails**: Uses Gemini AI to generate tailored cold emails.\n- \ud83d\udcec **Automated Email Sending**: Sends emails via Gmail API with attachments.\n- \u2705 **Email Verification**: Uses SMTP and Maileroo API to validate emails before sending.\n- \ud83d\uddc4 **Database Management**: Stores recruiter data in PostgreSQL and tracks outreach progress.\n- \ud83d\udd04 **Batch Processing**: Sends emails in batches with randomized delays to prevent spam detection.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Features",
                    "symbol": "Features",
                    "chunk_idx": 1,
                    "size": 529,
                    "_id": "2b1ec077-3dbf-5a35-8275-b58b0b6597fd",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "1. **Resume Loading**: The script reads the resume and stores its details in AI memory.\n2. **Recruiter Selection**: Fetches recruiters from the database who haven't been contacted.\n3. **Email Verification**: Ensures the email is valid before sending.\n4. **AI-Generated Email**: Gemini AI crafts a custom email based on the recruiter's details.\n5. **Automated Sending**: Uses Gmail API to send the email with an attached resume.\n6. **Logging & Tracking**: Updates the database to mark recruiters as contacted.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "How It Works",
                    "symbol": "How It Works",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "6dcf5e32-a80e-5849-aa46-ad41296904c3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "genai.configure(api_key=API_KEY)\nchat = genai.GenerativeModel('gemini-2.0-flash').start_chat(history=[])",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "Module",
                    "start_line": 88,
                    "end_line": 89,
                    "symbol": "None",
                    "chunk_idx": 5,
                    "size": 104,
                    "_id": "1154c6b9-d133-500d-a3f6-38dd38fc41c8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- [CTC Paper](https://www.cs.toronto.edu/~graves/icml_2006.pdf)\n- [CRNN Architecture](https://arxiv.org/abs/1507.05717)  \nThis project is for educational purposes. Feel free to use and modify as needed.  \n---  \n**Happy coding! \ud83d\ude80**",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\udcda Resources",
                    "symbol": "\ud83d\udcda Resources",
                    "chunk_idx": 17,
                    "size": 230,
                    "_id": "9f806412-10e4-5a7b-be49-08175ab1d285",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "A PyTorch-based CAPTCHA recognition system using synthetic data generation and CTC-based sequence modeling. Built with deep learning techniques, achieving high accuracy on complex text recognition tasks.",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "None",
                    "symbol": "CAPTCHA OCR Project",
                    "chunk_idx": 1,
                    "size": 203,
                    "_id": "89c221f0-2ced-5f9a-9c1d-e200c57f37f5",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- **Framework**: FastAPI\n- **Data Engine**: Polars & Pandas\n- **ML/DL**: PyTorch, Scikit-Learn, LightGBM, XGBoost\n- **Deployment**: Docker, Uvicorn\n- **Utilities**: Joblib, NumPy, Matplotlib/Seaborn  \n---\nDeveloped by **Mohak Kapoor**",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Tech Stack",
                    "symbol": "Tech Stack",
                    "chunk_idx": 5,
                    "size": 234,
                    "_id": "8b922ee1-0b4a-551f-bbf5-e1dcbbbca9b8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Environment Setup\n```bash\n# Install PyTorch with CUDA support (adjust version as needed)\npip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128\n\n# Install other dependencies\npip install captcha pandas pillow\n```  \n### 2. Generate Training Dataset\n```bash\ncd src\npython data.py\n```\nThis creates 10,000 synthetic CAPTCHAs in `Dataset_test/captchas/` with proper train/val/test splits.  \n### 3. Start Training\n```bash\npython train.py\n```\nThis starts the full training pipeline with automatic metrics generation.  \n### 4. Monitor Progress\nTraining will show:\n- Real-time loss and prediction samples\n- Automatic plot generation in `Metrics/` folder\n- Comprehensive training logs and summaries",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83d\ude80 Quick Start",
                    "symbol": "\ud83d\ude80 Quick Start",
                    "chunk_idx": 7,
                    "size": 721,
                    "_id": "3b357f42-2155-5453-a29c-795d0e1c9c09",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "[![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=for-the-badge&logo=fastapi)](https://fastapi.tiangolo.com)\n[![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)\n[![PyTorch](https://img.shields.io/badge/PyTorch-EE4C2C?style=for-the-badge&logo=pytorch&logoColor=white)](https://pytorch.org/)\n[![Docker](https://img.shields.io/badge/Docker-2496ED?style=for-the-badge&logo=docker&logoColor=white)](https://www.docker.com/)  \nAn enterprise-grade **Network Intrusion Detection System (NIDS)** backend powered by a state-of-the-art hierarchical machine learning pipeline. This system doesn't just predict; it verifies anomalies through a multi-layered \"Veto\" logic to ensure maximum accuracy and minimum false alarms.  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "None",
                    "symbol": "Intrusion Tracker Backend",
                    "chunk_idx": 0,
                    "size": 805,
                    "_id": "7eef7577-628b-5a31-b8c1-60aa64a23e9f",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "For technical implementation details, model architectures, and full API specifications, please refer to our:  \n### [Detailed Documentation](./documentation.md)  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Deep Dive",
                    "symbol": "Deep Dive",
                    "chunk_idx": 4,
                    "size": 165,
                    "_id": "7a094734-5ac2-5143-96e1-283fed011c43",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "You can explore the project and its capabilities live at:\n**[https://www.mohakapoor.in/projects/IntrusionDetection](https://www.mohakapoor.in/projects/IntrusionDetection)**  \n---",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\README.md",
                    "filename": "README.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend",
                    "h2": "Live Demo",
                    "symbol": "Live Demo",
                    "chunk_idx": 1,
                    "size": 178,
                    "_id": "2def1051-610d-504d-9077-7dbfd2fdb006",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Clone the Repository  \n```sh\ngit clone https://github.com/your-username/HermesGPT.git\ncd HermesGPT\n```  \n### 2. Install Dependencies  \nMake sure you have Python installed, then install the required packages:  \n```sh\npip install -r requirements.txt\n```  \n### 3. Configure Database  \nSet up a PostgreSQL database with the following schema:  \n```sql\nCREATE TABLE recruiters (\nemail TEXT PRIMARY KEY,\nrecruiter_name TEXT,\ncompany_name TEXT,\nrole TEXT,\ncontacted BOOLEAN DEFAULT FALSE\n);\n```  \n### 4. Set Up Gmail API  \n1. Enable the Gmail API from Google Cloud Console.\n2. Download `credentials.json` and place it in the project directory.\n3. Run authentication:  \n```sh\npython main.py\n```  \n### 5. API Keys  \n- **Gemini AI API**: Add your Gemini API key to the `API_KEY` variable.  \n### 6. Load Recruiter Data  \nPrepare a CSV file (`recruiters.csv`) with the following columns:  \n| Email | Name | Company | Title |\n|-------|------|---------|-------|",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Setup Instructions",
                    "symbol": "Setup Instructions",
                    "chunk_idx": 2,
                    "size": 953,
                    "_id": "c1147930-c01b-59e0-a7d4-b6330fbf4ec4",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project is open-source under the [MIT License](LICENSE).",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "License",
                    "symbol": "License",
                    "chunk_idx": 7,
                    "size": 61,
                    "_id": "78185ef9-2fd2-5572-ab65-88d727f873b2",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def api_name():\n    return {\"api_name\": \"Intrusion Detection API\"}",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 40,
                    "end_line": 41,
                    "symbol": "api_name",
                    "chunk_idx": 5,
                    "size": 72,
                    "_id": "9bf1f6da-08a0-57e2-ad5a-6c00e473cfcc",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "def generate_test_captcha(text, filename, width=256, height=60):\n    \"\"\"Generate a test CAPTCHA image using enhanced generation.\"\"\"\n    # Use the enhanced CAPTCHA generation from generateCaptcha.py\n    img = generate_captcha(text, width=width, height=height)\n    \n    # Ensure results directory exists\n    os.makedirs(cfg.RESULT_DIR, exist_ok=True)\n    \n    filepath = os.path.join(cfg.RESULT_DIR, filename)\n    img.save(filepath)\n    print(f\"Generated enhanced test CAPTCHA: {filename}\")\n    return filepath",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 72,
                    "end_line": 83,
                    "symbol": "generate_test_captcha",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "02bb7bcc-c46c-5763-ac36-ecf2ea7cbcd3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "\"\"\"\nSimple CAPTCHA Generation Utility\nGenerates individual CAPTCHA images using enhanced rendering\n\"\"\"\nimport random\nimport string\nfrom PIL import Image, ImageDraw, ImageFilter\nimport numpy as np\nimport cv2\nimport io\nIMG_WIDTH = 256\nIMG_HEIGHT = 60\nGRAYSCALE = True\nCHARS = string.ascii_letters + string.digits\nCAPTCHA_LEN_LOWER_LIMIT = 5\nCAPTCHA_LEN_UPPER_LIMIT = 7",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 19,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 366,
                    "_id": "09eca634-dc2d-51df-8d00-ffce645259c8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "if __name__ == \"__main__\":\n    # Example usage\n    print(\"Generating sample CAPTCHAs...\")\n    \n    # Generate with specific text\n    img1 = generate_captcha(\"HELLO\", save_path=\"sample_HELLO.png\")\n    print(f\"Generated: sample_HELLO.png\")\n    \n    print(\"Done! Check the generated images.\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 173,
                    "end_line": 181,
                    "symbol": "None",
                    "chunk_idx": 8,
                    "size": 289,
                    "_id": "cd687ca0-251d-504d-8d1e-2fbea96f05a4",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def ui_generate():\n    text = random_text()\n    filename = f\"{text}_{random.randint(1000,9999)}.png\"\n    # Use generateCaptcha.py directly\n    img = generate_captcha(text, width=cfg.W_max, height=cfg.H)\n    \n    # Save to results directory\n    filepath = os.path.join(cfg.RESULT_DIR, filename)\n    img.save(filepath)\n\n    # Enable and turn Solve green now that an image exists\n    solve_btn_state = gr.update(interactive=True, variant=\"primary\")\n    return img, text, filepath, solve_btn_state",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\app.py",
                    "filename": "app.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 41,
                    "end_line": 53,
                    "symbol": "ui_generate",
                    "chunk_idx": 3,
                    "size": 493,
                    "_id": "211ef5b1-f157-5df3-b832-8ec1395cd101",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_captcha(text=None, width=IMG_WIDTH, height=IMG_HEIGHT, save_path=None):\n    \"\"\"\n    Generate a single enhanced CAPTCHA image.\n    \n    Args:\n        text (str, optional): Text to render. If None, generates random text.\n        width (int): Image width\n        height (int): Image height\n        save_path (str, optional): Path to save the image. If None, returns PIL Image.\n    \n    Returns:\n        PIL Image if save_path is None, otherwise saves and returns the path\n    \"\"\"\n    # Generate random text if none provided\n    if text is None:\n        text = ''.join(random.choices(CHARS, k=random.randint(CAPTCHA_LEN_LOWER_LIMIT, CAPTCHA_LEN_UPPER_LIMIT)))\n    \n    # Randomize basic style\n    bg_choice = random.choice([\"solid\", \"gradient\"])\n    fg_color = rand_color(0, 80)\n    \n    if bg_choice == \"solid\":\n        bg_color = rand_color(210, 255)\n        bg = Image.new(\"RGB\", (width, height), color=bg_color)\n    else:\n        bg = gradient_bg(width, height)\n\n    # Adjust font sizes for larger dimensions\n    font_sizes = [int(height * 0.7), int(height * 0.75), int(height * 0.8), int(height * 0.85)]\n    font_size = random.choice(font_sizes)\n    \n    # Use ImageCaptcha for base text rendering\n    from captcha.image import ImageCaptcha\n    image = ImageCaptcha(width=width, height=height, fonts=None, font_sizes=[font_size])\n    \n    # Draw base image\n    base = Image.frombytes('RGB', (width, height), image.generate_image(text).tobytes())\n\n    # Apply enhancements\n    angle = random.uniform(-6, 6)\n    base = base.rotate(angle, resample=Image.BILINEAR, expand=False, fillcolor=bg.getpixel((0,0)))\n\n    # Perspective warp (very light)\n    if random.random() < 0.6:\n        base = perspective_warp(base, max_ratio=0.025)\n\n    # Add interference\n    base = add_interference(base, line_range=(0, 3), dot_range=(10, 60))\n\n    # Noise + blur + JPEG recompression\n    base = add_noise_and_blur(base, noise_sigma=(0.0, 5.0), blur_sigma=(0.0, 0.7), motion_prob=0.12)\n    base = jpeg_recompress(base, qmin=72, qmax=92)\n\n    # Optional low contrast\n    if random.random() < 0.2:\n        base = base.point(lambda p: int(p*0.95 + 6))\n\n    # Convert to grayscale if specified\n    if GRAYSCALE:\n        base = base.convert('L')\n    \n    # Save or return\n    if save_path:\n        base.save(save_path)\n        return save_path\n    else:\n        return base",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 104,
                    "end_line": 170,
                    "symbol": "generate_captcha",
                    "chunk_idx": 7,
                    "size": 2362,
                    "_id": "5961a050-0f46-5993-aadb-d341153dadc1",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "\"\"\"\nSimple CAPTCHA Generation Utility\nGenerates individual CAPTCHA images using enhanced rendering\n\"\"\"\nimport random\nimport string\nfrom PIL import Image, ImageDraw, ImageFilter\nimport numpy as np\nimport cv2\nimport io\nIMG_WIDTH = 256\nIMG_HEIGHT = 60\nGRAYSCALE = True\nCHARS = string.ascii_letters + string.digits\nCAPTCHA_LEN_LOWER_LIMIT = 5\nCAPTCHA_LEN_UPPER_LIMIT = 7",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py",
                    "filename": "generateCaptcha.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 19,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 366,
                    "_id": "09eca634-dc2d-51df-8d00-ffce645259c8",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "This project implements an end-to-end CAPTCHA OCR system that can recognize text in CAPTCHA images. It uses:\n- **Synthetic CAPTCHA generation** for training data\n- **CRNN (CNN + RNN) architecture** for sequence recognition\n- **CTC (Connectionist Temporal Classification)** loss for training\n- **PyTorch** with CUDA support for GPU acceleration",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfaf Project Overview",
                    "symbol": "\ud83c\udfaf Project Overview",
                    "chunk_idx": 2,
                    "size": 343,
                    "_id": "43771423-20e5-54f3-a5d2-86f6a9285d92",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_test_captcha(text, filename, width=256, height=60):\n    \"\"\"Generate a test CAPTCHA image using enhanced generation.\"\"\"\n    # Use the enhanced CAPTCHA generation from generateCaptcha.py\n    img = generate_captcha(text, width=width, height=height)\n    \n    # Ensure results directory exists\n    os.makedirs(cfg.RESULT_DIR, exist_ok=True)\n    \n    filepath = os.path.join(cfg.RESULT_DIR, filename)\n    img.save(filepath)\n    print(f\"Generated enhanced test CAPTCHA: {filename}\")\n    return filepath",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\inference.py",
                    "filename": "inference.py",
                    "repo": "CaptchaOCR",
                    "language": "python",
                    "type": "function",
                    "start_line": 72,
                    "end_line": 83,
                    "symbol": "generate_test_captcha",
                    "chunk_idx": 4,
                    "size": 508,
                    "_id": "02bb7bcc-c46c-5763-ac36-ecf2ea7cbcd3",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "A PyTorch-based CAPTCHA recognition system using synthetic data generation and CTC-based sequence modeling. Built with deep learning techniques, achieving high accuracy on complex text recognition tasks.",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "None",
                    "symbol": "CAPTCHA OCR Project",
                    "chunk_idx": 1,
                    "size": 203,
                    "_id": "89c221f0-2ced-5f9a-9c1d-e200c57f37f5",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### \u2705 Completed Components\n- **Dataset Generation**: Synthetic CAPTCHA creation with train/val/test splits (8k train, 1k val)\n- **Configuration**: Centralized config with image dimensions and training parameters\n- **Vocabulary System**: Character encoding/decoding with CTC blank token support (63 classes)\n- **CTC Collate Function**: Proper batching for variable-length sequences\n- **CTC Decoding**: Greedy decode for inference\n- **PyTorch Dataset Class**: Image loading and preprocessing with proper cv2 resizing\n- **CRNN Model**: CNN encoder + BiLSTM + LayerNorm + linear output (working!)\n- **Training Loop**: Complete epoch-based training pipeline with validation\n- **Metrics & Plotting**: Training/validation loss tracking with beautiful visualizations\n- **Debugging Tools**: Comprehensive logging of logits, predictions, and model health  \n### \u2705 What's Working\n- **Training Pipeline**: Stable training loop with excellent loss convergence",
                "metadata": {
                    "path": "knowledge_base\\repos\\CaptchaOCR\\README.md",
                    "filename": "README.md",
                    "repo": "CaptchaOCR",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "CAPTCHA OCR Project",
                    "h2": "\ud83c\udfd7\ufe0f Current Status",
                    "symbol": "\ud83c\udfd7\ufe0f Current Status",
                    "chunk_idx": 3,
                    "size": 945,
                    "_id": "cc52b2b4-6738-5973-9c50-29fc8882ca66",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "### Public Endpoints  \n#### Get API Information\n`GET /intrusiondetection/api_name`\n- **Response**: `{\"name\": \"Intrusion Detection API\", \"version\": \"1.0.0\"}`  \n#### Health Check\n`GET /intrusiondetection/health`\n- **Response**: `{\"status\": \"healthy\"}`  \n---  \n### Protected Endpoints (Requires Bearer Token)  \n#### Hybrid Detection (Recommended)\n`POST /intrusiondetection/predict/hybrid`\nUses the hierarchical pipeline: **Anomaly detection (Unsupervised) -> Classification (Supervised)**.\n- **Logic**: If the Autoencoder or Isolation Forest flags the flow, the Supervised models (LightGBM, FFNN, etc.) are invoked. LightGBM provides the final \"Veto\" to determine if it is truly an attack.  \n#### Prediction By Index\n`POST /intrusiondetection/predict/hybrid_by_index`\nUsed for testing existing samples from the `unscaled_test.parquet` dataset.\n- **Request Body**:\n```json\n{\n\"index\": 17502\n}\n```  \n#### Direct Model Endpoints\n- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 4,
                    "size": 996,
                    "_id": "7d8dce36-12e3-5b9e-aebf-bacb964ca11b",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "- `POST /predict/logreg`\n- `POST /predict/lightgbm`\n- `POST /predict/ffnn`\n- `POST /predict/autoencoder`\n- `POST /predict/isolationForest`\n- `POST /predict/xgboost`  \n---  \n### WebSocket Streaming\n`WS /intrusiondetection/ws/stream`\nStreams the dataset in batches of 100 rows with real-time statistics.  \n**Initialization Message**:\nAfter connecting, send the following JSON:\n```json\n{\n\"command\": \"start\",\n\"token\": \"your_secure_token_here\",\n\"start_at\": 0\n}\n```  \n**Final Summary Message**:\nAt the end of the stream, the server sends a summary containing final statistics and average latencies:\n```json\n{\n\"type\": \"summary\",\n\"status\": \"Stream Complete\",\n\"statistics\": {\n\"accuracy\": 0.85,\n\"total_processed\": 1000,\n\"correct_predictions\": 850,\n\"actual_counts\": {\"0\": 100, \"1\": 750, ...},\n\"predicted_counts\": {\"0\": 120, \"1\": 730, ...},\n\"average_latencies\": {\n\"autoencoder\": 0.000123,\n\"isolation_forest\": 0.000045,\n\"ffnn\": 0.000456,\n\"lightgbm\": 0.000789,\n\"logreg\": 0.000012,\n\"xgboost\": 0.000890,",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\documentation.md",
                    "filename": "documentation.md",
                    "repo": "IntrusionBackend",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "Intrusion Tracker Backend - Project Documentation",
                    "h2": "API Reference",
                    "symbol": "API Reference",
                    "chunk_idx": 5,
                    "size": 987,
                    "_id": "28326c1c-8329-5ba1-adda-3be25637f266",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "async def predict_isolation_forest_endpoint(\n    data: PredictionInput,\n    token: str = Depends(verify_token)\n):\n\n    try:\n        raw_sample,idx = sampler(data.target_class)\n        try:\n            predictions, lat = predict._predict_isolation_forest(raw_sample)\n            return {\"target_class\": data.target_class,\n                    \"prediction\": int(predictions),\n                    \"row_index\": int(idx),\n                    \"detection_time\": round(lat, 6)}\n        except Exception as e:\n            raise HTTPException(status_code=500, detail=f\"Prediction error: {str(e)}\")\n    except Exception as e:\n        raise HTTPException(status_code =500,detail =f\"Sampling error : {str(e)}\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "async_function",
                    "start_line": 127,
                    "end_line": 143,
                    "symbol": "predict_isolation_forest_endpoint",
                    "chunk_idx": 11,
                    "size": 696,
                    "_id": "817b33a8-3fe4-5a69-a4f3-be3f7bf2b9e7",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def generate_stats():\n    total_rows = len_df()\n    print(f\"Starting evaluation on {total_rows} rows...\")\n    \n    y_true = []\n    y_pred = []\n    \n    # Iterate through the dataset\n    for idx in tqdm(range(total_rows)):\n        try:\n            result = predict.predict_attack_by_idx(idx)\n            \n            actual = result[\"target_class\"]\n            # Logic: If status is Attack Detected, use the LightGBM prediction. \n            # Otherwise, it's Benign (0).\n            if result[\"status\"] == \"Attack Detected\":\n                predicted = result.get(\"supervised\", {}).get(\"lightgbm\", 0)\n            else:\n                predicted = 0\n                \n            y_true.append(actual)\n            y_pred.append(predicted)\n        except Exception as e:\n            print(f\"Error at index {idx}: {e}\")\n            continue\n\n    # 1. Generate Text Report\n    report = classification_report(y_true, y_pred)\n    cm = confusion_matrix(y_true, y_pred)\n    \n    output_text = \"=== CONFUSION MATRIX ===\\n\"\n    output_text += str(cm) + \"\\n\\n\"\n    output_text += \"=== CLASSIFICATION REPORT ===\\n\"\n    output_text += report\n    \n    with open(\"confusion_matrix.txt\", \"w\") as f:\n        f.write(output_text)\n    \n    print(\"\\nText report saved to confusion_matrix.txt\")\n\n    # 2. Generate Heatmap Plot\n    plt.figure(figsize=(12, 10))\n    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n                xticklabels=np.unique(y_true), \n                yticklabels=np.unique(y_true))\n    plt.title(\"Intrusion Detection Confusion Matrix\\n(Hierarchical Pipeline with LGBM Veto)\")\n    plt.xlabel(\"Predicted Class\")\n    plt.ylabel(\"Actual Class\")\n    plt.savefig(\"confusion_matrix.png\", dpi=300)\n    plt.close()\n    \n    print(\"Plot saved to confusion_matrix.png\")\n\n    # 3. Generate Classification Report Heatmap\n    report_dict = classification_report(y_true, y_pred, output_dict=True)\n    # Convert to DataFrame and remove support/averages for plotting\n    report_df = pd.DataFrame(report_dict).iloc[:-1, :].T\n    report_df = report_df.drop(['accuracy', 'macro avg', 'weighted avg'], axis=0, errors='ignore')\n    \n    plt.figure(figsize=(10, 8))\n    sns.heatmap(report_df, annot=True, cmap='Blues')\n    plt.title(\"Classification Report Metrics per Class\")\n    plt.savefig(\"classification_report.png\", dpi=300)\n    plt.close()\n    \n    print(\"Plot saved to classification_report.png\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\stats.py",
                    "filename": "stats.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "function",
                    "start_line": 14,
                    "end_line": 79,
                    "symbol": "generate_stats",
                    "chunk_idx": 1,
                    "size": 2387,
                    "_id": "efed5473-b5ea-53c4-bf8f-15863894d13a",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "from fastapi import FastAPI, APIRouter, HTTPException, Depends, Security, WebSocket, WebSocketDisconnect\nfrom fastapi.security import HTTPBearer, HTTPAuthorizationCredentials\nfrom pydantic import BaseModel, validator\nfrom typing import Dict, Any, List\nimport pandas as pd\nimport os\nimport asyncio\nfrom utils import sampler, len_df\nfrom dotenv import load_dotenv\nimport predict\nfrom cors import configure_cors\nload_dotenv()\napp = FastAPI(title=\"Intrusion Detection API\", version=\"1.0.0\")\nconfigure_cors(app)\nrouter = APIRouter(prefix=\"/intrusiondetection\")",
                "metadata": {
                    "path": "knowledge_base\\repos\\IntrusionBackend\\router.py",
                    "filename": "router.py",
                    "repo": "IntrusionBackend",
                    "language": "python",
                    "type": "Module",
                    "start_line": 1,
                    "end_line": 17,
                    "symbol": "None",
                    "chunk_idx": 0,
                    "size": 555,
                    "_id": "9290d52e-db69-5505-a4c7-38447a1c4add",
                    "_collection_name": "code_atlas"
                }
            }
        ],
        [
            {
                "text": "HermesGPT is an intelligent automation tool designed to streamline the process of reaching out to recruiters for internship opportunities. It integrates AI-generated personalized cold emails, database management, email verification, and automated sending using Gmail API.",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "None",
                    "symbol": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "chunk_idx": 0,
                    "size": 271,
                    "_id": "8b6916d8-be29-5c9f-9c4a-5a0be949d971",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "def connect_db():\n    return psycopg2.connect(\n            dbname = \"hermesgpt\",\n            user = \"postgres\",\n            password = \"1234\",\n            host = \"localhost\",\n            port = \"5432\",\n        )",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\hermesgpt.py",
                    "filename": "hermesgpt.py",
                    "repo": "HermesGPT",
                    "language": "python",
                    "type": "function",
                    "start_line": 24,
                    "end_line": 31,
                    "symbol": "connect_db",
                    "chunk_idx": 1,
                    "size": 211,
                    "_id": "9bcf0b9c-6035-513a-b23f-891addfaf645",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "{\n  \"repository_name\": \"HermesGPT\",\n  \"owner\": \"mohakapoor\",\n  \"tracked_branch\": \"main\",\n  \"current_commit_sha\": \"d491677ab7439b321a6fafdc7b5a57b150b01c01\",\n  \"indexed_commit_sha\": \"\",\n  \"index_queue\": [\n    \"*\"\n  ],\n  \"available_branches\": [\n    \"main\"\n  ],\n  \"topics\": [\n    \"knowledge-base\"\n  ],\n  \"languages\": [\n    \"Python\"\n  ],\n  \"last_sync_timestamp\": \"2026-07-30T08:05:09.140927+00:00\"\n}",
                "metadata": {
                    "repo": "HermesGPT",
                    "path": "knowledge_base/repos/HermesGPT/manifest.json",
                    "filename": "manifest.json",
                    "language": "text",
                    "type": "text",
                    "chunk_idx": 0,
                    "size": 395,
                    "_id": "e59205a1-6759-5d88-bdd7-1b5a90211240",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "### 1. Clone the Repository  \n```sh\ngit clone https://github.com/your-username/HermesGPT.git\ncd HermesGPT\n```  \n### 2. Install Dependencies  \nMake sure you have Python installed, then install the required packages:  \n```sh\npip install -r requirements.txt\n```  \n### 3. Configure Database  \nSet up a PostgreSQL database with the following schema:  \n```sql\nCREATE TABLE recruiters (\nemail TEXT PRIMARY KEY,\nrecruiter_name TEXT,\ncompany_name TEXT,\nrole TEXT,\ncontacted BOOLEAN DEFAULT FALSE\n);\n```  \n### 4. Set Up Gmail API  \n1. Enable the Gmail API from Google Cloud Console.\n2. Download `credentials.json` and place it in the project directory.\n3. Run authentication:  \n```sh\npython main.py\n```  \n### 5. API Keys  \n- **Gemini AI API**: Add your Gemini API key to the `API_KEY` variable.  \n### 6. Load Recruiter Data  \nPrepare a CSV file (`recruiters.csv`) with the following columns:  \n| Email | Name | Company | Title |\n|-------|------|---------|-------|",
                "metadata": {
                    "path": "knowledge_base\\repos\\HermesGPT\\README.md",
                    "filename": "README.md",
                    "repo": "HermesGPT",
                    "language": "markdown",
                    "type": "section",
                    "start_line": "None",
                    "end_line": "None",
                    "h1": "HermesGPT - Automated Internship Outreach Bot \ud83d\ude80",
                    "h2": "Setup Instructions",
                    "symbol": "Setup Instructions",
                    "chunk_idx": 2,
                    "size": 953,
                    "_id": "c1147930-c01b-59e0-a7d4-b6330fbf4ec4",
                    "_collection_name": "code_atlas"
                }
            },
            {
                "text": "# User Repository Map\n\nThis document maps all repositories, folders, and files in the knowledge base.\nUse this to understand the high-level structure of the portfolio.\n\n## [CaptchaOCR]\n```text\n\u251c\u2500\u2500 checkpoints\n\u251c\u2500\u2500 Metrics\n\u2502   \u251c\u2500\u2500 .gitkeep\n\u2502   \u2514\u2500\u2500 training_metrics.txt\n\u251c\u2500\u2500 src\n\u2502   \u251c\u2500\u2500 captcha_dataset.py\n\u2502   \u251c\u2500\u2500 collate.py\n\u2502   \u251c\u2500\u2500 config.py\n\u2502   \u251c\u2500\u2500 data.py\n\u2502   \u251c\u2500\u2500 generateCaptcha.py\n\u2502   \u251c\u2500\u2500 model_crnn.py\n\u2502   \u251c\u2500\u2500 plotting.py\n\u2502   \u251c\u2500\u2500 test.py\n\u2502   \u2514\u2500\u2500 vocab.py\n\u251c\u2500\u2500 .gitattributes\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 app.py\n\u251c\u2500\u2500 inference.py\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 requirements.txt\n\u251c\u2500\u2500 train.py\n\u2514\u2500\u2500 train_sanity.py\n```\n\n## [HermesGPT]\n```text\n\u251c\u2500\u2500 hermesgpt.py\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 README.md\n\u2514\u2500\u2500 requirements.txt\n```\n\n## [IntrusionBackend]\n```text\n\u251c\u2500\u2500 cross_dataset_results\n\u2502   \u251c\u2500\u2500 autoencoder_report.txt\n\u2502   \u251c\u2500\u2500 ffnn_report.txt\n\u2502   \u251c\u2500\u2500 isolation_forest_report.txt\n\u2502   \u251c\u2500\u2500 lightgbm_report.txt\n\u2502   \u251c\u2500\u2500 logreg_report.txt\n\u2502   \u251c\u2500\u2500 pipeline_report.txt\n\u2502   \u2514\u2500\u2500 xgboost_report.txt\n\u251c\u2500\u2500 models\n\u2502   \u251c\u2500\u2500 logreg_b.npy\n\u2502   \u2514\u2500\u2500 logreg_W.npy\n\u251c\u2500\u2500 scalers\n\u251c\u2500\u2500 .dockerignore\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 confusion_matrix.txt\n\u251c\u2500\u2500 cors.py\n\u251c\u2500\u2500 docker-compose.yml\n\u251c\u2500\u2500 dockerfile\n\u251c\u2500\u2500 documentation.md\n\u251c\u2500\u2500 manifest.json\n\u251c\u2500\u2500 pcap_to_cicids.py\n\u251c\u2500\u2500 predict.py\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 requirements.txt\n\u251c\u2500\u2500 router.py\n\u251c\u2500\u2500 stats.py\n\u251c\u2500\u2500 stats_cicds2018.py\n\u251c\u2500\u2500 test.py\n\u2514\u2500\u2500 utils.py\n```\n",
                "metadata": {
                    "repo": "global",
                    "path": "portfolio_graph",
                    "language": "markdown",
                    "type": "global_graph",
                    "_id": "fd1e2143-57fe-5730-96e7-c5347468f47c",
                    "_collection_name": "code_atlas"
                }
            }
        ]
    ],
    "ground_truth": [
        "The CaptchaDataset class for loading synthetic CAPTCHA images is defined in src/captcha_dataset.py.",
        "Image transformations and augmentations, such as perspective warping, interference lines, blurring, and JPEG artifacts, are primarily implemented in src/generateCaptcha.py (and mirrored in src/data.py for dataset generation).",
        "The PyTorch DataLoader is used in train.py to create the train_dl and val_dl iterators, which feed batched data into the training and validation loops.",
        "The ctc_collate function in src/collate.py handles batching by stacking the image tensors, encoding text labels into a flattened 1D tensor (targets_flat), and calculating the target_lengths and input_lengths required by the CTC loss function.",
        "The Gemini API is called in hermesgpt.py using chat.send_message(). It is called inside the model_loading function to ingest a resume, and inside the initial_outreach function to generate the cold email body.",
        "Ensemble decision-making is handled in predict.py within the predict_attack and predict_attack_by_idx functions. The system first checks unsupervised models (Autoencoder and Isolation Forest), and if an anomaly is flagged, it evaluates supervised models, placing the final decision weight primarily on LightGBM.",
        "Yes, multiple workers are handled in router.py. The application is started using Uvicorn with the workers=4 parameter, enabling 4 worker processes.",
        "For the OCR model, the vocabulary is generated statically in src/vocab.py by creating character-to-index mappings (itos and stoi) from config.py's character set. It could be made better by implementing sub-word tokenization (like BPE) instead of character-level, or by adding support for special symbols/punctuation.",
        "Yes, data sampling is handled in utils.py for the IntrusionBackend project. Instead of a traditional database, it loads a parquet file (unscaled_test.parquet) into memory using the polars library and provides functions like sampler() to fetch random rows by class, or sample_by_index() to fetch specific rows.",
        "Authentication is handled in router.py using Bearer tokens (FastAPI HTTPBearer). The verify_token dependency checks if the provided credentials match the TOKEN environment variable. For WebSockets, the token is passed in the initial JSON payload.",
        "There is no live demo link provided in the CaptchaOCR README. The README only provides instructions on how to run it locally or on Colab.",
        "The CaptchaOCR project is about Optical Character Recognition (OCR). It implements an end-to-end system using a CRNN (CNN + RNN) architecture to recognize text in CAPTCHA images.",
        "To run CaptchaOCR locally, first install PyTorch and other dependencies (captcha, pandas, pillow). Then, generate the dataset by running python data.py inside the src folder. Finally, run python train.py to start training, or python inference.py for testing the model.",
        "Based on the CaptchaOCR README, the project uses synthetic data generation to train the model, not real-life captured images.",
        "To run the IntrusionBackend project, it is recommended to use Docker. First, copy the .env.example to .env and fill in your token. Then, run docker-compose up --build to start the FastAPI server on http://localhost:8000.",
        "To add a new model in predict.py, you need to: 1) Load the model globally (e.g., via joblib or torch.load) at the top of the file. 2) Create a helper wrapper function (e.g., _predict_newmodel) that handles data scaling, model inference, and latency tracking. 3) Call this wrapper inside the main predict_attack and predict_attack_by_idx pipelines, appending its prediction and latency to the final result dictionary.",
        "The Intrusion Backend uses a hierarchical machine learning pipeline. It first passes network flow data through Unsupervised Anomaly Detection models (Autoencoders, Isolation Forests). If an anomaly is detected, it acts as a 'Veto' logic, triggering Supervised Classification models (LightGBM, XGBoost, FFNN) to make the final determination.",
        "To install the dependencies for CaptchaOCR, use pip to install PyTorch with CUDA support (e.g., pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128), and then install the required Python packages by running pip install captcha pandas pillow.",
        "While the README only shows a generic Python badge, the dockerfile explicitly requires python:3.11-slim as its base image.",
        "There are no specific contribution guidelines provided in the IntrusionBackend README.",
        "Both CaptchaOCR and IntrusionBackend use PyTorch. CaptchaOCR uses it heavily for its CRNN model architecture and training pipeline. IntrusionBackend uses PyTorch for its Autoencoder and FFNN models.",
        "Yes, the HermesGPT project (hermesgpt.py) automates mass sending of cold emails using the Gmail API and Gemini.",
        "Yes, you can use the IntrusionBackend project (router.py) as a reference. It is a fully featured FastAPI application with routing, token authentication, and WebSockets.",
        "The CaptchaOCR project is a PyTorch-based OCR system that uses a CRNN architecture to recognize text in images.",
        "The IntrusionBackend project serves as an excellent FastAPI template. Its router.py demonstrates API routing, middleware integration, token-based authentication, and WebSocket streaming.",
        "The HermesGPT project (hermesgpt.py) is an email automation system that generates personalized cold emails using AI and sends them via the Gmail API.",
        "You can find a WebSocket implementation in the IntrusionBackend project within router.py, specifically under the /ws/stream endpoint which streams batched prediction data in real-time.",
        "The CaptchaOCR project contains a complete PyTorch training pipeline in train.py. It includes dataset loading, epoch-based training, CTC loss calculation, learning rate scheduling, and validation logic.",
        "In the IntrusionBackend project, the allowed CORS origins configured in cors.py are: https://mohakapoor.in, https://sisyphus.mohakapoor.in, http://mohakapoor.in, http://sisyphus.mohakapoor.in, and http://localhost:8000.",
        "CORS origins are configured in the cors.py file within the IntrusionBackend project using FastAPI CORSMiddleware.",
        "In the IntrusionBackend project, environment variables are loaded in docker-compose.yml via the env_file: directive, which points to the .env file.",
        "Docker is configured in the dockerfile for the IntrusionBackend. It uses the python:3.11-slim base image, installs system dependencies (like libgomp1), copies the code, installs Python packages from requirements.txt, and sets CMD ['python', 'router.py'] to start the application.",
        "GitHub Actions configurations are typically found in a .github/workflows/ directory, but there are no GitHub Actions workflows defined in the current codebase.",
        "Preprocessing and scaling are configured in utils.py. The file handles missing/infinite values, drops constant or redundant columns, downcasts data types, and applies scaling using pre-trained MinMaxScaler (scale_unsupervised) and StandardScaler/PCA (scale_supervised).",
        "Yes, rate limiting is implemented in hermesgpt.py within the batch_mailing function using a random time.sleep(random.randint(30,120)) between sending each email to avoid triggering spam filters or hitting API limits.",
        "Inference works by loading the trained CRNN model checkpoint, preprocessing the image to the target tensor size, passing it through the model to get logits, and then using greedy CTC decoding to generate the final text prediction.",
        "Live websocketing works in router.py through the /ws/stream endpoint. Once the client connects and authenticates with a JSON payload, the server starts an asynchronous loop that evaluates rows of network data in batches, returning real-time predictions, latencies, and accuracy statistics back to the client.",
        "An image travels from upload to prediction by first being preprocessed (loaded via OpenCV, resized to 60x256, normalized, and converted to a tensor), then passed into the CRNN model. The model outputs logits, which are finally converted into a readable text string using CTC greedy decoding.",
        "WebSocket clients are managed in router.py by accepting the connection with await websocket.accept(), checking for a valid authentication token in the first received JSON message, and keeping the connection open in a loop to stream data until completion or a WebSocketDisconnect exception occurs, at which point the connection is closed safely.",
        "The training pipeline in train.py loads the PyTorch CaptchaDataset via DataLoaders. It initializes the CRNN model, CTCLoss, AdamW optimizer, and OneCycleLR scheduler. The pipeline runs epoch loops containing forward/backward passes, calculates training and validation loss, handles early stopping, saves checkpoints, and generates metric plots.",
        "No, there are no Rust projects in the current repository portfolio.",
        "No, Kubernetes is not used in the current repositories. Deployment configurations use Docker and Docker Compose.",
        "No, Redis Streams are not used in the current projects.",
        "No, GraphQL has not been implemented. The APIs are RESTful (e.g., using FastAPI).",
        "The IntrusionBackend repository uses FastAPI for its REST API and WebSocket implementation, specifically defined in router.py.",
        "The HermesGPT project uses the Gemini API (gemini-2.0-flash) via the google.generativeai package to automate cold email generation.",
        "The CaptchaOCR project uses PyTorch heavily for its CRNN model architecture, custom Dataset, and training pipeline (train.py). The IntrusionBackend also uses PyTorch for its Autoencoder and FFNN models.",
        "The IntrusionBackend project exposes REST APIs using FastAPI in router.py.",
        "generate_captcha is a function located in src/generateCaptcha.py within the CaptchaOCR project. It generates synthetic CAPTCHA images with configurable text, fonts, and augmentations.",
        "The synthetic CAPTCHA dataset generation pipeline is orchestrated in src/data.py, which creates labeled training, validation, and test datasets of images using the render_with_variation function.",
        "There isn't a function explicitly named predict_intrusion, but the primary inference pipelines in predict.py are predict_attack and predict_attack_by_idx, which evaluate network flow data against multiple intrusion detection models.",
        "HermesGPT is an email automation tool found in hermesgpt.py. It uses the Gemini API to parse resumes and generate personalized cold emails for recruiters, sending them automatically via the Gmail API."
    ],
    "relevant_files": [
        [
            "knowledge_base\\repos\\CaptchaOCR\\src\\captcha_dataset.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\train.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\src\\collate.py"
        ],
        [
            "knowledge_base\\repos\\HermesGPT\\hermesgpt.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\predict.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\src\\vocab.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\utils.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\README.md"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\README.md"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\README.md"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\README.md"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\README.md"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\predict.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\README.md"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\README.md"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\dockerfile"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\README.md"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\train.py",
            "knowledge_base\\repos\\IntrusionBackend\\train.py"
        ],
        [
            "knowledge_base\\repos\\HermesGPT\\hermesgpt.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\README.md"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\HermesGPT\\hermesgpt.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\train.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\cors.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\cors.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\docker-compose.yml"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\dockerfile"
        ],
        [],
        [
            "knowledge_base\\repos\\IntrusionBackend\\utils.py"
        ],
        [
            "knowledge_base\\repos\\HermesGPT\\hermesgpt.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\inference.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\inference.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\train.py"
        ],
        [],
        [],
        [],
        [],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\HermesGPT\\hermesgpt.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\train.py",
            "knowledge_base\\repos\\IntrusionBackend\\train.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\router.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\src\\generateCaptcha.py"
        ],
        [
            "knowledge_base\\repos\\CaptchaOCR\\src\\data.py"
        ],
        [
            "knowledge_base\\repos\\IntrusionBackend\\predict.py"
        ],
        [
            "knowledge_base\\repos\\HermesGPT\\hermesgpt.py"
        ]
    ]
}