Projects

Overview: This project is a visual tool designed to help developers compare and understand the effectiveness of six different Retrieval-Augmented Generation (RAG) chunking strategies. It includes real-time grading and query selection, allowing users to see the differences between strategies immediately. Key features: - 6 strategies: Fixed-size, Recursive, Sentence, Markdown, Regex, Semantic - Live quality grading: Green (clean), Yellow (warnings), Red (broken chunks) - Visual diff view: Hover any chunk to highlight it in the doc - Cost calculator: Embedding + context window costs for OpenAI/Cohere - Export code: LangChain, LlamaIndex, Haystack snippets - Zero backend: Runs 100% client-side (except semantic uses OpenAI API) Tech stack: Pure vanilla JavaScript, custom CSS, DM Sans, Fira Code, Caveat fonts, uses BM25 for query selection, GPT-3 estimation for token counting. Why it matters: Most RAG tutorials skip chunking or say "just use 512 tokens." This tool helps developers see the difference and understand why chunking strategy matters, especially in terms of retrieval accuracy and cost. Repository: ai-agents-buzz/rag-chunking-playground Primary language: HTML GitHub stars: 14 GitHub description: Visual tool to compare 6 RAG chunking strategies side-by-side with grading and query selection.

### Overview: This project is a production-grade, security-first AI platform built entirely on a single local Kubernetes cluster, using GitOps for deployment and management. The platform includes features such as self-hosted GPU LLM serving, full observability, and no cloud dependencies. ### Key Features: - **Self-Hosted GPU LLM Serving**: A model serving system designed for GPU resources. - **GitOps Workflow**: Deployments and updates are managed using GitOps principles. - **Kyverno Policy Enforcement**: Ensures image policies are enforced. - **Kyverno Enforce Mode**: Custom rules for runtime security. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno Enforce Mode**: Custom rules for runtime security. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images before deployment. - **Kyverno VerifyImages**: Validates images

Overview: This repository features a specialized dual-agent training pipeline designed to master complex Python concepts. By combining **Supervised Fine-Tuning (SFT)** for formatting and **Group Relative Policy Optimization (GRPO)** for reasoning, the system evolves a "Base" model into a high-difficulty **AI Examiner**. Key features: - Two-Stage Q-Agent Training - Warmup (SFT): Aligns the model to strict JSON schemas - Strategic Evolution (GRPO): Optimizes for question complexity, technical keywords, and logical depth using verifiable reward functions - Verifiable Reward Pipeline: Uses a "Sniper Parser" in `rewards.py` to grade responses on format, length, and subject matter difficulty - Unsloth Integration: 2x faster training with optimized VRAM usage, enabling RL training on consumer-grade laptop GPUs (RTX 5050+) - Battle Interface: A simulated environment where the trained agents are pitted against each other to verify learning progress Tech stack: Python Why it matters: This repository showcases innovative techniques in reinforcement learning and fine-tuning to create a highly effective AI Examiner, capable of generating questions that even advanced LLMs struggle to answer.

Overview: This repository contains advanced techniques for fine-tuning large language models (LLMs) across various domains, including math reasoning, multi-hop question answering, medical question answering, and general question answering. It utilizes Supervised Fine-Tuning, Reinforcement Learning with Group Relative Policy Optimization (GRPO), and Preference Alignment, among other methods. Key features: - **LoRA (Low-rank Weight Updates)**: Low-rank weight updates applied to attention and feed-forward projection matrices. - **QLoRA (4-bit NF4 Quantization)**: LoRA with 4-bit NF4 quantization of the base model via BitsAndBytes. - **DoRA (Weight-Decomposed LoRA)**: Decomposes weights into magnitude and direction, applies LoRA to the directional component. - **P-Tuning (Trains a Small Encoder Network)**: Trains a small encoder network to produce continuous prompt embeddings. - **Prefix-Tuning (Prepends Trainable Prefix Vectors)**: Prepends trainable prefix vectors to the key and value tensors of every attention layer. - **Datasets**: Includes datasets like ARC, TriviaQA, FactScore, PopQA, and Earnings Calls for various domains. Tech stack: The repository is built on HuggingFace TRL, PEFT, and Unsloth, with reward functions powered by DeepEval and Evidently AI. Why it matters: This repository provides comprehensive implementations of fine-tuning techniques for LLMs across multiple domains, enhancing the performance and applicability of LLMs in various tasks.

Overview: Wan 2.7 Image API (`wan2.7-image`) is a service that provides access to a wide range of image models via the OpenAI-compatible APIMart endpoint, offering unsubscription-based pricing and flexible image generation capabilities. Key features: - Supports multiple image, video, and language models - Provides API key for free access to the Wan 2.7 Image model - Offers a minimum cost of $1 per use, with charges factored into each completed task - Asynchronous processing with task tracking via `GET /v1/tasks/{task_id}` Tech stack: Python Why it matters: This API streamlines the process of generating high-quality images, making it accessible without the need for a subscription, while ensuring cost-effective usage through flexible pricing models. Repository: b05qswr9inv/wan2-7-image-api-es Primary language: Python GitHub stars: 13

Overview: Seedance 2.0 Prompts offers tested image prompt recipes with example renders, aspect ratios, the model id (`seedance-2.0`), and the cost per image on the APIMart route. This includes 8 recipes with their durations and costs. Key features: - 8 tested recipes with example renders, aspect ratios, and the model id (`seedance-2.0`). - Cost per image on the APIMart route. - Pricing details: $0.04 per second, no need for a monthly plan. - Non-blocking design: Uses `task_id` to track progress and polling for batch processing. Tech stack: Python Why it matters: Seedance 2.0 Prompts provides a straightforward way to access models like `seedance-2.0` and other 300+ models via the APIMart route, without needing a subscription. It offers flexible pricing and non-blocking design, making it ideal for developers looking to integrate AI prompts into their projects.

### Overview: Visual Question Generation (VQG) is a model that generates answers to visual questions using a combination of textual and visual information. This implementation is based on the paper "Multimodal Differential Network for Visual Question Generation" by Patro et al., published at the 2018 Conference on Empirical Methods in Natural Language Processing. ### Key Features: - **Torch Implementation**: The code is written in Lua, utilizing the Torch framework for efficient computation. - **Data Preparation**: The dataset is downloaded from MicrosoftVQG, and the images are preprocessed using specific scripts for joint and attention models. - **Exemplar Image Finding**: The script finds supporting and opposing images using a local image retrieval method. - **Training Script**: The training process involves downloading the dataset, creating train, val, and test JSON files, and running the `train.lua` script. ### Tech Stack: Lua ### Why it Matters: This implementation provides a practical solution for generating answers to visual questions, which can be particularly useful in applications like image captioning, visual question answering, and more. The ability to leverage both textual and visual information enhances the model's performance and applicability in various domains.

Overview: This project fine tunes YOLOv111 to detect fires using a dataset of 751 images. Key features: - Fine-tuned YOLOv111 model for fire detection - Preprocessing of images with auto-orientation and resizing - Detailed run summary and model performance metrics - Fine-tuning results and curves - Detections of fires in various images Tech stack: Python Why it matters: This project showcases the effectiveness of fine-tuning YOLOv111 for real-world applications, particularly in detecting fires in images, which is crucial for early warning systems and safety measures. Repository: bhaskrr/fire-detection-using-yolov11 GitHub stars: 14 GitHub description: A fine tuned yolov111 model to detect fire

Overview: This skill provides a comprehensive set of patterns for AI agents, including model discovery, multimodal chat, tool calling, routing, and production playbooks, all ready to integrate into projects. Key features: - Model Discovery - Image Generation - Multimodal Chat - Cost Controls - Routing & Fallbacks - Tool Calling - Provider, Free & Discounted Models - Starter Templates - Asset Workflows - Production Playbooks - Safer Defaults - Verification Tech stack: TypeScript Why it matters: This skill streamlines the development process by providing pre-built patterns and best practices, reducing the need for developers to start from scratch with each project. Repository: bnishit/openrouter-skill Primary language: TypeScript GitHub stars: 14 GitHub description: OpenRouter skill for AI agents: model discovery, multimodal chat, tool calling, routing, and starter templates. GitHub URL: [bnishit.github.io/openrouter-skill](https://bnishit.github.io/openrouter-skill/)

### Overview: Coloma is a Continuous Verification and Optimization layer designed for self-hosted Large Language Models (LLMs). It ensures optimal performance and prevents runtime crashes by tuning deployments and comparing models. ### Key Features: - **Tune vLLM Deployments**: Maximize desired metrics and prevent crashes. - **Model Comparison and Deployment**: Compare and deploy tuned models. - **OpenAI Proxy**: Sit between workload and endpoint, compatible with OpenAI. - **Live and Saved Traffic Inspection**: Monitor and analyze traffic. - **Image Optimization**: Optimize base64 images before GPU usage. - **Structured Output Schema Validation**: Validate and validate output schemas. - **Idle-Compute Verification**: Re-run heavier checks when idle. - **Chat Interface**: User-friendly chat interface. - **On-Premise Only**: Runs 100% on-prem, no data sent to third-party. ### Tech Stack: Python ### Why It Matters: Coloma ensures high performance and reliability for self-hosted LLMs, making it an essential tool for developers looking to optimize their models and infrastructure. ### Repository: colomalabs/coloma ### GitHub Stars: 14 ### GitHub Description: The Continuous Verification and Optimization layer for self-hosted LLMs

Overview: This project focuses on fine-tuning and supervised fine-tuning of LLaMA-3-8B models for TLDR summarization using various prompt engineering techniques and metrics. Key features: - Adapted `folder_inference.py` for more efficient prediction of text files within a folder. - Used `prompt_eng_templates.py` to create Jinja2 templates and render text for input and output examples. - Measured performance metrics such as ROUGE-1, ROUGE-2, and ROUGE-L using 5 different prompts. Tech stack: Python Why it matters: Despite using a smaller model with 8-bit quantization, the second prompt shows better results, indicating potential improvements in performance with further fine-tuning and optimization.

Overview: This Rust project is an implementation of the LLaMA2 model, inspired by the original C code. It includes features like model loading, forward pass, generation, and tokenization, with performance metrics provided. Key features: - Model loading - Forward pass - Generation - Tokenization - Performance metrics (tokens/sec) Tech stack: Rust Why it matters: This project showcases the performance and efficiency of Rust in deep learning applications, demonstrating how it can be used to accelerate the training and inference of large language models. Repository: danielgrittner/llama2-rs Primary language: Rust GitHub stars: 14 GitHub description: LLaMA2 + Rust README excerpt: LLaMA2 port for Rust inspired by `llama2.c`. (TODOs: Implement loading, forward pass, generation, support prompting, tokenization, command line args, parallelization, quantization, optimize performance)

Overview: This boilerplate provides a comprehensive AI-powered platform for football statistics analysis and real-time insights using LangChain v3, multiple LLM models, and advanced agent orchestration. Key features: 1. Multi-Model LLM Integration: OpenAI GPT-4 Turbo for complex analysis, Groq Mixtral-8x7b for real-time processing, and Model Selection Logic for automatic model selection. 2. Advanced Agent Architecture: Supervisor Agent for orchestration, specialized agents for different tasks, and RAG (Retrieval Augmented Generation) for context retrieval. 3. RAG (Retrieval Augmented Generation): Vector store integration, Redis-based document storage, dynamic context retrieval, and automatic document embedding and indexing. 4. Memory Management: Redis-based chat history, vector store memory, context window management, and session management. 5. Tool Integration: Football Data Tool, Live Scores Tool, Stats Calculator Tool, Timeframe Tool, and Dynamic Tool Loading. 6. Multiple Interfaces: CLI Interface for interactive command-line processing and REST API for HTTP-based communication. 7. Advanced Features: Query Processing Pipeline, Structured Output, Error Handling, and Graceful Degradation. Tech stack: TypeScript Why it matters: This boilerplate offers a robust and scalable solution for football analysis and real-time insights, leveraging advanced AI and multi-model reasoning capabilities. GitHub stars: 14 Repository: denizumutdereli/langchain-multi-agents-boilerplate

### Overview: MCPg is a production-grade Model Context Protocol (MCP) server for PostgreSQL, designed to safely inspect, query, operate, and tune a Postgres database. It includes 279 tools for catalog introspection, query intelligence, natural-language SQL, structural diffs, hybrid search, graph queries, data movement, live ops, and more. ### Key Features: - **Read-Only Access Mode:** Ensures safety with read-only access by validating every SQL statement through an AST allowlist. - **Production-Grade Observability:** Provides detailed insights into database health and performance. - **Multi-Tenancy Support:** Allows multiple users to access the database simultaneously without conflicts. - **Easy Installation:** Requires `pip install mcpg` for quick setup. - **Supported PostgreSQL Versions:** 14–19. ### Tech Stack: Python ### Why It Matters: - **Safety First:** Ensures secure and reliable database access with read-only mode. - **Versatile Tools:** A comprehensive set of tools for both application data access and database management. - **Production-Grade:** Designed for high-availability and performance in production environments. ### Repository: Repository: devopam/MCPg Primary Language: Python GitHub Stars: 14 ### Quick Start: - **Demo Endpoint:** Point an MCP client or MCP Inspector at `https://devopam-mcpg-demo.hf.space/mcp` for read-only access. - **Run Next to Your Database:** For real use, run MCPg alongside your own database. ### Listings:

### Overview: Qwen-Image 3.0 prompts: tested image prompt recipes with example renders, aspect ratios, the model id (`qwen-image-3.0`) and the cost per image. ### Key features: - **Model ID:** `qwen-image-3.0` - **Example Renders:** Eight recipes with detailed prompts and costs - **Aspect Ratios:** 1:1, 4:3, 3:2, 8:5, 2:3, 16:9, 1:16, 1:4 - **Cost Per Image:** $0.0206 ### Tech Stack: Python ### Why it Matters: The provided recipes offer a practical guide for creating high-quality images using Qwen-Image 3.0, ensuring consistency and efficiency in image generation.

### Overview: 即梦视频 — Seedance 2.0 Mini prompts: tested image prompt recipes with example renders, aspect ratios, the model id (`seedance-2.0-mini`) and the cost per image. ### Key features: - **Model ID:** `seedance-2.0-mini` - **Example Renders:** Product ad, Cinematic, Food commercial, Architecture - **Duration:** 5 seconds - **Cost Per Image:** $0.066 ### Tech Stack: Python ### Why It Matters: A versatile and cost-effective tool for generating high-quality images and videos using the Seedance 2.0 Mini model. Ideal for content creators and marketers looking to enhance their visuals with professional-grade results without the need for a subscription-based service.

### Overview: A RAG application built with .NET 8, Microsoft Semantic Kernel, Azure OpenAI, Qdrant, Docker, and PdfPig, designed to provide reliable answers grounded in private PDF documents. ### Key features: - **Retrieval-grounded responses** based on supplied PDF documents - **Multilingual questions and answers** - **Semantic search** using document embeddings - **Persistent vector storage** with Qdrant - **PDF text extraction** using PdfPig - **Conversational interface** using Semantic Kernel - **Docker-based Qdrain deployment** - **Designed to reduce unnecessary LLM context and token usage** ### Tech stack: C# / .NET 8 ### Why it matters: The project demonstrates how RAG can be implemented entirely within the .NET ecosystem, showcasing the potential of integrating AI tools within the .NET stack.

Overview: Z Image Turbo is a high-speed AI image generation model that allows developers to create stunning images from text prompts with flexible aspect ratios and lightning-fast processing. Key features: - **Model ID and Routes**: Access 300+ models via a single `model` field, with pricing based on the number of images generated. - **Pricing**: Prices are per delivered image, with a list price of $0.0125 and an effective price of $0.01. - **Request Parameters**: Accepts fields such as `model`, `prompt`, `size`, `resolution`, `n`, and `image_urls`. - **Quickstart**: Provides a simple command-line and Python example to get started quickly. Tech stack: Python Why it matters: Z Image Turbo simplifies the process of generating high-quality images from text prompts, making it an essential tool for developers looking to integrate AI into their projects efficiently and cost-effectively. Repository: ej094tn/z-image-api-ja Primary language: Python GitHub stars: 12 GitHub description: Z Image Turbo API (`z-image-turbo`): model id, pricing, parameters and copy-paste examples for the OpenAI-compatible APIMart endpoint.

Overview: Seedance 2.0 API is an OpenAI-compatible endpoint providing model id, pricing, and parameters for image, video, and language generation. It offers a single endpoint compatible with OpenAI, with a price of $0.04 per second on the APIMart route. Key features: - Model id and pricing information - Parameters for image, video, and language generation - Asynchronous processing - Billing by resolution and duration - Model id and routes for different variants Tech stack: Python Why it matters: Seedance 2.0 API simplifies the process of using multiple Seedance 2.0 models with a single endpoint, making it easier and more cost-effective for developers to integrate AI into their projects.

### Overview: EBind is a comprehensive multi-modal embedding model that supports image, video, audio, text, and 3D point cloud inputs. It projects all modalities into a shared embedding space, enabling cross-modal similarity computations. ### Key Features: - **Image, Video, Audio, Text, and 3D Point Cloud Support**: EBind can handle various types of input data including images, videos, audio, text, and 3D point clouds. - **Cross-Modal Similarity**: It computes similarity between different modalities, facilitating cross-modal retrieval and understanding. - **Efficient Processing**: The model is designed to be efficient and fast, making it suitable for real-time applications. ### Tech Stack: Python ### Why It Matters: EBind is essential for applications that require the integration of multiple modalities for better understanding and analysis of complex data. Its ability to handle diverse inputs and compute cross-modal similarities makes it a valuable tool in fields such as computer vision, natural language processing, and more. Repository: encord-team/ebind GitHub Stars: 14 GitHub Description: A 5-way embedding model for text, audio, image, video, and 3D point clouds. Tech Stack: Python Why It Matters: EBind is essential for applications that require the integration of multiple modalities for better understanding and analysis of complex data.