Projects

Overview: This project provides a comprehensive template for building a Retrieval-Augmented Generation (RAG) system using Google Gemini and MongoDB Atlas. Ideal for developers looking to integrate factual, up-to-date knowledge into their AI applications. Key features: - Vector Store: MongoDB Atlas Vector Search for storing and retrieving document embeddings. - Embeddings: Powered by Google's `model/embeddings-001`. - LLM: Uses Google's `gemini-2.5-flash` model for generating responses. - Framework: Built using LangChain and Streamlit. Tech stack: Python Why it matters: This project offers a practical guide for developers to build and deploy a reliable RAG system, enhancing their AI applications with factual, up-to-date knowledge.

### Overview: AksharaMD is a document ingestion pipeline designed to evaluate the AI readiness of a chosen parser. It provides a per-document readiness score and structured Markdown/JSON output, ensuring the quality and substance of the parsed document. ### Key Features: - **AI Readiness Score**: Grades the parser's ability to parse the document into an AI-friendly Markdown option. - **Per-Block Extraction Confidence**: Tags each block as EXTRACTED, INFERRED, or AMBIGUOUS. - **Named Warnings**: Provides warnings for common issues like OCR required, low text density, and repeated content. ### Tech Stack: Python ### Why It Matters: AksharaMD ensures that the parser you choose performs optimally on a per-document basis, providing insights into the quality and substance of the parsed content. It helps identify and address issues that might otherwise go unnoticed, ensuring that the final output is as useful and accurate as possible.

Overview: This project examines the impact of mergers and acquisitions (M&A) on stock price fluctuations, offering investors a tool to build a diversified investment portfolio based on their risk preferences. Key features: - Data Acquisition: Gathering data from various sources including images, CSV files, PDFs, web scraping from URLs, and video content. - RAG-Based Application: Utilizing a Retrieval-Augmented Generation (RAG) approach to store data in a Vector Database, generate synthetic data, and create CSV files for further analysis. - Training and Prediction: Training models to predict stock price movements based on M&A activity and analyze historical trends to prepare a correlation matrix for related stocks. - Targeting Companies for M&A: Developing strategies to identify potential companies for mergers and acquisitions, considering market trends, company performance metrics, and user-defined risk factors. Tech stack: Flask application. Why it matters: This project provides valuable insights into the complex relationships between M&A activities and stock price fluctuations, enabling investors to make informed decisions and build diversified investment portfolios tailored to their risk preferences. GitHub stars: 9 Repository: Kartik-Katkar/Multifaceted-Impact-of-Mergers-and-Acquisitions-on-Stock-Price-Fluctuations

### Overview: Ant is an open-source vector database designed for embedding similarity search. It leverages Faiss for efficient indexing and Faiss-CPU for compatibility, ensuring robust data security and consistency through Redis's RDB and AOF mechanisms. ### Key Features: - Faiss-based vector database for similarity search - Faiss-CPU for compatibility - Redis hybrid data backup mechanism for security and consistency - Docker-supported build and run environment - RESTful API for easy instance management and data operations ### Tech Stack: Python ### Why it Matters: Ant is a powerful tool for developers looking to implement efficient vector similarity search capabilities, making it ideal for applications requiring high performance and scalability in similarity-based data retrieval tasks. ### GitHub Stars: 9 ### Repository: LongmaoTeamTf/ant ### Primary Language: Python ### License: Apache-2.0 ### Quick Start: ```shell script $ docker build -t ant:latest . $ docker run ant:latest -p 1234:1234 -v {logs_dir}:/ant/logs {data_dir}:/ant/data ``` ### Restful API: | Method | URL | Description | Status | | ------ | --- | ----------- | ------ | | POST | [/ant/create](RestfulAPI.md#创建实例) | Create the instance by name. | []() | | POST | [/ant/delete](RestfulAPI.md#删除实例) | Delete the instance by name. |

Overview: GUDA is a high-performance CPU-based CUDA-compatible linear algebra library designed for applications that require GPU acceleration but do not have access to a GPU. Key features: - Fixed-Function Unit (FFU) support for AVX512-VNNI, AES-NI, and AMX, providing significant speedup. - Aggressive SIMD optimization for improved performance. - Seamless deployment of CUDA applications on CPU-only infrastructure. Tech stack: Go. Why it matters: GUDA simplifies the development and deployment of CUDA applications on CPU-only systems, offering a practical alternative for performance-critical tasks that would otherwise require GPU hardware.

### Overview: KoNEFTune is a project that applies Random Noisy Embeddings with fine-tuning methodology to the LLaMA2 model using a Korean language model (Kosy-LLama). This approach allows for the integration of fine-tuning techniques into the Ko-LLM, enabling the model to be fine-tuned on specific tasks or datasets while maintaining the ability to generate noise in the embeddings. This method is particularly useful for improving the model's performance and generalization capabilities. ### Key Features: - **Random Noisy Embeddings**: The project introduces a method to add noise to the embeddings during training, which can help in improving the model's robustness and generalization. - **Fine-Tuning on Ko-LLM**: The project applies fine-tuning techniques to the LLaMA2 model using a Korean language model (Kosy-LLama), making it suitable for Korean language tasks. - **Integration with LLaMA2**: The project integrates fine-tuning methodology with the LLaMA2 model, allowing for the fine-tuning of the model on specific datasets or tasks. - **Code Implementation**: The project provides a quick training code snippet in Python, demonstrating how to fine-tune the model using the Ko-LLM. ### Tech Stack: - **Python**: The project is developed using Python, leveraging the capabilities of the LLaMA2 model and the Ko-LLM for fine-tuning. ### Why It Matters: - **Enhanced Performance**: The integration of fine-tuning techniques with the Ko-LLM can lead to

### Overview: This repository contains a website and associated Python scripts that rewrite open research papers into plain language, making them accessible to a curious 14-year-old. The project is part of a larger initiative to democratize scientific knowledge by translating academic papers into a format that is easy to understand. ### Key features: - **Rewritten Papers**: The website presents research papers in a simplified, child-friendly manner. - **Rewritten by Models**: The rewrite is done by a small model trained on a corpus of papers, aiming to make complex information understandable. - **Training Data**: The rewrite is based on the "paper-rewrites-for-young-readers" dataset, which includes training data, glossary entries, and figures from the original papers. ### Tech Stack: The project uses Python, TypeScript, and Hugging Face models to generate the rewritten papers. ### Why it Matters: This initiative aims to make scientific research more accessible to a broader audience, including children, by simplifying the language and context of the papers. It leverages AI to democratize knowledge, making it easier for everyone to understand and engage with scientific research.

Overview: docubot is a web application that enables users to chat with any document, enhancing their interaction with uploaded documents through a chat interface. Key features: - Develop chat UI - Implement Websocket for real-time communication - Support multiple vector databases - Incorporate various embedding models Tech stack: Python Why it matters: This project offers a unique way to interact with documents, making it useful for users who need to communicate with their files in a conversational manner. Repository: MindPal-Space/docubot Primary language: Python GitHub stars: 9

Overview: AirDrop-LLM is an offline, zero-dependency multi-node pipeline-parallel LLM inference broker that pools heterogeneous consumer hardware over ad-hoc local hotspot LANs. It runs 32B and 70B parameter models with zero cloud dependencies, enabling the use of state-of-the-art models locally without expensive cloud rentals or server racks. Key features: - Pools heterogeneous consumer laptops over local Wi-Fi into a unified distributed GPU cluster. - Runs 32B and 70B parameter models with zero cloud dependencies. - Seamless discovery and inference across peer laptops on the local network. Tech stack: Rust Why it matters: AirDrop-LLM solves the problem of running state-of-the-art models locally by enabling the use of these models without expensive cloud rentals or server racks, making it ideal for developers and researchers who need to run large models locally.

### Overview: GraphSense is a Python library designed to train and infer graph embedding-based code suggestion models. It simplifies the process of training and using these models with minimal preprocessing and resource consumption. ### Key Features: - **GraphSense**: A framework for training and using code suggestion models with minimal data preprocessing and resource consumption. - **Node2Vec Underlying Algorithm**: Uses the Node2Vec algorithm for graph embedding. - **FAISS Vector Index**: Utilizes FAISS for efficient vector indexing. - **RocksDB Storage**: Stores code line mappings and index mappings using RocksDB for efficient memory usage. - **High Performance**: Optimized for performance and efficiency, making it highly scalable. ### Tech Stack: - Python 3.8 or greater ### Why It Matters: GraphSense simplifies the process of training and using code suggestion models by providing a framework that minimizes preprocessing and resource consumption. This makes it highly efficient and scalable, making it suitable for various applications requiring code suggestion models. ### Repository: NavodPeiris/graphsense - GitHub Stars: 9 - GitHub Description: GraphSense is a library to train and infer graph embedding based code suggestion models. ### Installation: ```bash pip install graphsense ``` ### Training Example: ```python from graphsense import GraphTrain g = GraphTrain() # train the model g.line_completion(directory_path="code_files", language="Python") ``` ### Inference Example: ```python from graphsense import GraphInfer g = GraphInfer() g.load_artifacts() # load

Overview: This project fine-tunes Geospatial Foundation Models (Prithvi, TerraMind) for building footprint segmentation from Sentinel-2 imagery over Algiers, Algeria. It leverages TerraTorch, an open-source toolkit built on PyTorch Lightning and TorchGeo, to adapt pretrained GFM backbones for specific downstream tasks. Key features: - Multiple GFM backbones: Prithvi, TerraMind, SatMAE, ScaleMAE via TerraTorch model factories - Flexible decoders: UperNet, FPN, and segmentation decoders from SMP and mmsegmentation - Systematic comparison: Fine-tuning vs. training from scratch vs. ImageNet transfer - CLI + notebook workflows: Launch experiments via YAML configs or Jupyter notebooks - Algiers case study: Sentinel-2 building segmentation in an underrepresented urban area Tech stack: TerraTorch, PyTorch Lightning, TorchGeo Why it matters: Fine-tuning Geospatial Foundation Models for specific downstream tasks requires far fewer labeled samples than training from scratch, making them critical for underrepresented regions like North Africa where annotated datasets are scarce.

Overview: PocketComfy je nativní Android aplikace pro ovládání vlastního ComfyUI serveru, která generuje videa, obrázky, hudbu a opravu starých fotek. Lokální aplikace bez cloudu. Key features: - Video generace - Obrázky generace - Hudební generace - Hlas generace - 3D model generace - Vlastní počítač s serverem ComfyUI Tech stack: Kotlin Why it matters: PocketComfy umožňuje uživateli vlastním počítačem generovat kompletní AI studio, který je vždy dostupný a bez cloudu.

Overview: This project explores various generative AI techniques, focusing on image generation using Stable Diffusion. Key features: - Stable Diffusion-based image generation Tech stack: Jupyter Notebook Why it matters: This project showcases advanced generative AI techniques, particularly in image generation, which can be applied across various fields such as art, design, and simulation.

Overview: A lightweight utility designed to streamline the fine-tuning process for Llama models. Key features: - Fine-tuning of Llama models using a simple "just a few lines of code" approach. - Integration with popular datasets and formatting functions for consistent input/output. Tech stack: Python Why it matters: Simplifies the complex task of Llama model fine-tuning, making it accessible to developers without extensive knowledge in deep learning.

### Overview: This repository provides verified price rows across 24 providers for LLM inference costs, including 378 GPU rental rates and 395 throughput datapoints. The data is sourced from verified price rows and includes a self-hosting break-even model, with immutable snapshots and a CC BY 4.0 license. ### Key features: - Verified price rows across 24 providers - 378 GPU rental rates - 395 throughput datapoints - Self-hosting break-even model - Immutable snapshots - CC BY 4.0 license ### Tech stack: Python ### Why it matters: This repository answers a crucial question for developers and researchers about the true cost of LLM inference, providing a comprehensive and verified comparison across different pricing models and GPU configurations. The data is sourced from verified price rows and includes a self-hosting break-even model, making it a valuable resource for anyone looking to optimize their LLM inference costs.

### Overview: The `space-model` is a framework designed to fine-tune large pre-trained language models (LLMs) on specific datasets, ensuring enhanced performance on downstream tasks without compromising generalizability. ### Key Features: - Task-specific context attribution - Enhanced performance on downstream tasks - External LLM layer for improved accuracy in classification tasks ### Tech Stack: Python ### Why it Matters: The `space-model` framework is crucial for researchers and developers working with large language models, as it allows for better performance on specific datasets while maintaining generalizability, making it valuable for applications requiring high accuracy on specific tasks.

### Overview: Enterprise-Enhanced LLaMA Foundry Pro is an end-to-end LLM fine-tuning and deployment pipeline, integrating data augmentation & engineering, cloud-based training, and local deployment. It enables rapid iteration of models while keeping infrastructure flexible and secure. ### Key Features: - 📦 Data Engineering: EasyDataset for data management, enhancement, and standardization. - 🧠 Model Fine-tuning: LoRA, QLoRA, and DPO for efficient parameter tuning. - 🚀 Cloud-based Training: AutoDL for training job management and cloud-based data storage. - 🚀 Local Deployment: Ollama or llama.cpp for efficient model deployment. - 🤖 Model Quantization: GGUF for fast loading and saving of models. - 💼 Integration: Easy to integrate with RAG and LLM-based tools for knowledge-rich applications. ### Tech Stack: Python ### Why it Matters: Perfect for enterprise-grade applications, enabling rapid model iteration and flexible infrastructure management.

Overview: onenm_local_llm is a Flutter plugin that simplifies on-device language model inference on Android using llama.cpp. It removes the complexity of setting up native runtimes, model loading, and inference pipelines, allowing developers to integrate local AI into their apps through a simple API. Key features: - Simplifies on-device language model inference - Removes complexity of native runtimes, model loading, and inference pipelines - Introduces a simple, clean API for developers to integrate local AI into their apps Tech stack: Dart / Flutter for Android, Kotlin for Android Why it matters: Developers can easily integrate local AI into their apps without dealing with the complexities of setting up native runtimes, model loading, and inference pipelines, making it faster, private, and cost-effective.

### Overview: This project is a production-ready cart-to-purchase conversion prediction platform that uses a comprehensive end-to-end MLOps system. It includes data processing, model training, model registry, orchestration with Airflow DAGs, and a React-based frontend for prediction and model exploration. ### Key Features: - **Data Processing and Feature Generation:** Data is processed and features are generated to enhance model performance. - **Model Training and Registry:** The model is trained using MLflow and artifacts are stored in MinIO for easy access and version control. - **Orchestration:** Airflow DAGs are used to orchestrate the deployment of the serving API, ensuring a smooth and efficient workflow. - **Frontend:** A React-based dashboard is used for prediction and model exploration, providing a user-friendly interface. ### Tech Stack: - **Python:** The primary language used for the project. - **MLflow:** For model training and artifact management. - **MinIO:** For storing model artifacts. - **Kubernetes:** For orchestrating the deployment of the serving API. - **Docker:** For local development and continuous integration. - **React:** For the frontend development. ### Why it Matters: This project demonstrates the entire lifecycle of a production-ready machine learning model, from data preparation to deployment and monitoring. It showcases best practices in MLOps, including model training, model deployment, and model monitoring, making it a valuable resource for developers looking to implement similar systems in their projects.

### Overview: RSR-core is a high-performance engine for low-bit matrix-vector multiplication, designed for efficient inference with low-bit quantization. It targets fast matrix-vector multiplication when the matrix is low-bit quantized by grouping repeated column patterns, aggregating the corresponding input values once, and then scattering the result to the affected output rows. ### Key features: - **RSR (Redundant Segment Reduction)**: A method for efficient low-bit inference (matrix-vector multiplication) by grouping repeated column patterns, aggregating the corresponding input values once, and then scattering the result to the affected output rows. - **Cross-Device Support**: Built for both CPU and CUDA backends, ensuring compatibility across different hardware platforms. - **Model Integration**: Includes pre-built kernels for popular models like Hugging Face's `bitnet-b1.58-2B-4T` and supports integration with various models. ### Tech stack: Python ### Why it matters: RSR-core is crucial for applications requiring low-bit quantization, such as low-bit LLM inference, where decoding repeatedly applies quantized matvec operations. It optimizes performance by reducing redundant calculations, making it highly efficient and suitable for real-time inference tasks.