Project directory

Projects

Open-source AI projects tracked by the leaderboard, ordered by GitHub stars.

Python 8 stars

Anyesh/EVOKE

EVict and recOver KV cache Entries. Selective KV cache eviction and recovery for long-context LLM inference.

### Overview: EVOKE is a reversible KV-cache eviction and recovery system designed specifically for long-context language model inference. It addresses the issue of working set overflow by selectively evicting and recovering key-value pairs from a limited memory budget, ensuring that the model retains relevant context without losing important information. ### Key Features: - **Reversible KV-Eviction**: EVOKE allows for reversible eviction, where evicted key-value pairs can be recovered without losing the original computation. - **Selective KV-Eviction**: It selectively evicts and recovers key-value pairs based on their importance, ensuring that the most relevant context is retained. - **Recompute-Free Recall**: The system provides recompute-free recall of evicted key-value pairs, maintaining the original model state without recomputation. ### Tech Stack: - **Python**: The primary language used for implementing EVOKE. - **RoPE (Relative Position Encoding)**: Used in the splice mechanism to handle the repositioning of key-value pairs after eviction. ### Why It Matters: EVOKE is crucial for maintaining the effectiveness and efficiency of long-running language model sessions, ensuring that the model retains the most relevant context without losing important information. This system is particularly valuable in scenarios where the working set of a language model grows beyond its memory budget, such as in continuous interaction sessions or in scenarios where the model needs to handle long sequences of queries and responses. ### Repository: The repository for EVOKE is located at [Anyesh/EVOKE](https://github.com/Anyesh/EVOKE). ### GitHub Stars: The repository has been starred by 8 developers
Python 8 stars

Argonaut790/fused-turboquant

Fused Triton kernels for TurboQuant KV cache compression — 2-4 bit quantization with RHT rotation. Drop-in HuggingFace & vLLM integration. Up to 4.9x KV cache compression for Llama, Qwen, Mistral, and more.

### Overview: `fused-turboquant` is a high-performance Python library designed to compress the key-value (K and V) caches of large language models (LLMs) like Llama, Qwen, and Mistral to 2-4 bits using the TurboQuant algorithm. This compression achieves up to 4.9x memory compression with near-lossless quality, making it an essential tool for optimizing memory usage in these models. ### Key Features: - **Compression Ratio**: Compresses both K and V caches to 2-4 bits using TurboQuant, achieving up to 4.9x KV cache compression. - **Single Triton Kernel**: Fuses the entire encode/decode pipeline into a single Triton GPU kernel, reducing the number of kernels from 5+ to 1. - **RHT Rotation**: Uses RHT (Randomized Hadamard Transform) instead of dense QR rotation, offering O(d log d) compute and O(d) storage, fitting in registers. - **Drop-in Support**: Works seamlessly with HuggingFace Transformers and vLLM, providing a drop-in integration. - **Auto-detection**: Detects CUDA + Triton; falls back to unfused PyTorch on CPU. ### Tech Stack: - **Python**: The primary programming language used. - **CUDA + Triton**: Utilizes CUDA for GPU acceleration and Triton for optimized kernel execution. ### Why It Matters: - **Memory Efficiency**: Significantly reduces memory usage, making the models more efficient and faster. - **Performance**: Achieves up
Unknown 8 stars

BjornMelin/unified-knowledge-system

A comprehensive unified knowledge management system integrating multiple data sources with advanced search capabilities

### Overview The Unified Knowledge Management System is a comprehensive system designed to integrate multiple knowledge sources into a unified, searchable knowledge base with advanced retrieval capabilities. This system bridges the gap between different knowledge repositories, making it accessible through standardized interfaces. ### Key Features - **Vector Search**: Provides high relevance and context-aware knowledge retrieval. - **Knowledge Graph**: Stores entities and their relationships for graph-based queries. - **Traditional Document Storage**: Preserves original documents with metadata in JSON/Markdown format. - **MCP Server Layer**: Exposes technical documentation via stdio transport and web content via HTTP+. - **Integration Layer**: Facilitates seamless integration with various knowledge sources. ### Tech Stack The system is built using the following technologies: - **Vector Search**: Sentence Transformers (all-MiniLM-L6-v2) - **Knowledge Graph**: Qdrant Vector Database - **Structured Documents Store**: Obsidian Vault - **MCP Server Layer**: DevDocs MCP and Firecrawl MCP - **Integration Layer**: Unified Search Engine and Supergateway ### Why It Matters By combining vector search, knowledge graphs, and traditional document storage, our system provides comprehensive knowledge retrieval with high relevance and context awareness, making it a valuable tool for both users and AI assistants. ### Repository The project is hosted on GitHub and has received 8 GitHub stars. The primary language is not specified.
Python 8 stars

BonnBytes/CaRA

[ICML2025] Canonical Rank Adaptation: An Efficient Fine-Tuning Strategy for Vision Transformers

Overview: Canonical Rank Adaptation (CaRA) is an efficient fine-tuning strategy for Vision Transformers that addresses the limitations of low-rank adaptation methods by leveraging tensor mathematics to minimize the number of trainable parameters. Key features: - Tensorisation of the transformer into two different tensors - Fine-tuning using Canonical-Polyadic Decomposition (CPD) - Minimizes the number of trainable parameters Tech stack: Python Why it matters: CaRA efficiently adapts Vision Transformers by leveraging tensor mathematics, leading to improved performance in visual classification benchmarks.
Python 8 stars

CAI991108/Robotic-Action-Frame-Prediction-with-InstructPix2Pix

This repository contains the code and configuration files for training a multimodal fine-tuned `InstructPix2Pix` model to predict future robotic action frames. The model generates 256×256 resolution images conditioned on a current observation and textual instruction

### Overview: This repository contains the code and configuration files for training a multimodal fine-tuned `InstructPix2Pix` model to predict future robotic action frames. The model generates 256×256 resolution images conditioned on a current observation and textual instruction. ### Key features: - **Model Training**: Fine-tuned `InstructPix2Pix` model for robotic action frame prediction. - **Image Generation**: Generates images conditioned on observations and instructions. - **Performance**: Achieves SSIM up to 0.98 and PSNR over 40 dB on synthetic RoboTwin tasks. ### Tech stack: Python ### Why it matters: This repository is essential for researchers and developers looking to enhance robotic action prediction and robotic control systems. The model's ability to generate realistic images based on textual instructions and current observations opens up new possibilities for autonomous robotic systems.
Jupyter Notebook 8 stars

DNLab2024/BGP_LLaMA

BGP-LLaMA: Fine-tuning Open-Source LLM on BGP Routing Knowledge and Analysis

### Overview: BGP-LLaMA is the first open-source LLM specialized in BGP routing analytics, fine-tuned with a dataset collected from Internet standard documents and papers. This model can answer BGP routing questions and automate BGP analysis tasks. ### Key features: - Fine-tuned LLaMA-13B model - BGP training data from Internet standard documents and papers - Instruction-tuned LLaMA-13B model - Can answer BGP routing questions - Automate BGP analysis tasks ### Tech stack: Jupyter Notebook ### Why it matters: BGP-LLaMA is the first open-source LLM designed for BGP routing analytics, offering a comprehensive solution for understanding and automating BGP routing data.
Rust 8 stars

Dakera-AI/dakera-cli

dk — CLI for Dakera self-hosted AI agent memory. Manage memories, namespaces, vectors, knowledge graphs, and sessions.

Overview: Dakera CLI is a command-line interface designed for managing a Dakera self-hosted AI agent memory, including inspecting and managing memories, namespaces, vectors, knowledge graphs, and sessions. Key features: - Inspect and manage Dakera memory instances - Store and retrieve memories - Perform semantic queries and full-text searches Tech stack: Rust Why it matters: Dakera CLI provides a straightforward way to interact with a Dakera memory instance, making it easier to manage and analyze data stored within the AI agent's memory. Repository: Dakera-AI/dakera-cli GitHub stars: 8 GitHub description: dk — CLI for Dakera self-hosted AI agent memory. Manage memories, namespaces, vectors, knowledge graphs, and sessions. GitHub license: MIT License GitHub description: [benchmark details](https://dakera.ai/benchmark)
Python 8 stars

Dark-Vinaal/RAG

"A Retrieval-Augmented Generation (RAG) chatbot built with LangChain, Streamlit, and FAISS, designed to answer questions accurately from custom documents (PDFs)"

Overview: This project is a Retrieval-Augmented Generation (RAG) chatbot built with LangChain, Streamlit, and FAISS, designed to answer questions accurately from custom documents (PDFs). Key features: - 📄 PDF Knowledge Ingestion - ✂️ Smart Text Chunking - 🧠 Semantic Search with FAISS - 🎯 Experience-Aware Answers - 💬 Interactive Chat UI - 🔒 Offline & Private Tech stack: Python, Streamlit, LangChain, FAISS, Ollama. Why it matters: This project showcases the integration of advanced natural language processing techniques to create a highly effective and user-friendly chatbot solution for answering questions from custom documents. Repository: Dark-Vinaal/RAG GitHub stars: 8 GitHub description: "A Retrieval-Augmented Generation (RAG) chatbot built with LangChain, Streamlit, and FAISS, designed to answer questions accurately from custom documents (PDFs)."
Python 8 stars

Di-Zhu123/ActionUNet

Official implementation of “ActionUNet: Improving Robustness of VLA Models with Efficient Multi-scale Fine-tuning” (NeurIPS 2026)

Overview: ActionUNet is an official implementation of the "ActionUNet: Improving Robustness of VLA Models with Efficient Multi-scale Fine-tuning" paper presented at NeurIPS 2026. This project aims to enhance the robustness of Vision-Language-Action (VLA) models by incorporating a temporal U-Net and a conditional SIREN decoder. Key features: - Action generation using a multi-scale, temporally smooth approach - Supports both flow-based and regression-based policies - Official PyTorch implementation for NeurIPS 2026 Tech stack: Python Why it matters: ActionUNet is designed to improve the robustness of VLA models by enhancing their ability to generate actions in various scenarios, making it particularly useful in applications requiring high accuracy and reliability. Repository: Di-Zhu123/ActionUNet GitHub stars: 8 GitHub description: Official implementation of "ActionUNet: Improving Robustness of VLA Models with Efficient Multi-scale Fine-tuning" (NeurIPS 2026) README excerpt: <div align="center"> <h2>ActionUNet: Improving Robustness of VLA Models with<br>Efficient Multi-scale Fine-tuning</h2> <p> <b>Di Zhu</b><sup>1,*</sup> &middot; <b>Ziheng Yan</b><sup>1,*</sup> &middot; <b>Fang Wan</b><sup>1,&dagger;</sup
Python 8 stars

Dmartinez-96/agentic-council

The agentic council is a fully configurable wrapper to introduce a novel method for cross-family critical red-teaming and evaluation of a "leader" agent's work. This is NOT an oracle. It is a toolchain designed to force agents into more honest, thoroughly verified workflows in a configurable, agent-agnostic way.

### Overview: The agentic council is a fully configurable wrapper designed to introduce a novel method for cross-family critical red-teaming and evaluation of a "leader" agent's work. This toolchain forces agents into more honest, thoroughly verified workflows in a configurable, agent-agnostic way. ### Key Features: - **Claude Code Integration**: The agentic council integrates with Claude Code, providing a council on every `Write`, `Edit`, or `NotebookEdit` that refuses lazy "out of scope" / "GPU required" / "not feasible" caveats unless a backing probe actually ran. - **Plain Subprocess Review**: The engine can be invoked as a plain subprocess, not just a hook, and the actor it reviews (the tool-using leader) is now a selectable role, not only Claude. - **Two-Tier Review Process**: The review runs in two tiers: six voting critics plus a six-model non-voting inspector tier from further model families. It does not trust the actor's account of its own work. Neither should you. ### Tech Stack: Python ### Why it Matters: The agentic council is a powerful tool for evaluating and improving the work of agents in a controlled and transparent manner, ensuring that the work is evaluated based on evidence and not just assumptions. This toolchain is designed to be agent-agnostic, making it useful across different model families and environments.
HTML 8 stars

Drobiazkin/agent-gpu-calculator

Single-file GPU/RAM sizing calculator for LLM agent sessions on vLLM: KV-cache offload to RAM, prefix caching, MLA/DSA and hybrid models, TP chosen per model × GPU pair (H100–B300). Runs in the browser, no dependencies.

### Overview: This single-file web calculator is designed to size GPUs and host RAM for LLM agent sessions on vLLM, optimizing KV-cache offload and prefix caching for improved performance. ### Key features: - **GPU and RAM Estimation**: Calculates the required number of GPUs and host RAM for a specified number of live agents or steps per day. - **Presets**: Supports various LLM models and platforms, including Qwen3-Coder, Qwen3-235B-A22B-2507, Qwen3-32B, and others. - **Preset Profiles**: Offers enterprise documents, reasoning, and chat in Russian as load profiles. - **Confidence Labels**: Provides confidence labels for model presets, derived from multiple sources for accuracy. ### Tech stack: HTML ### Why it matters: This tool helps developers optimize GPU and RAM usage for efficient LLM agent sessions, ensuring optimal performance and resource management.
Shell 8 stars

EvoLinkAI/OpenClaw-Image-Generator

A Claude Code skill (standard Skill format) for generating AI images via the Evolink Z-Image-Turbo API. Cross-platform, zero dependencies.

Overview: This is a Claude Code skill designed to generate AI images using the Evolink Z-Image-Turbo API. It is cross-platform, requiring no shell escaping or dependencies. Key features: - Cross-platform compatibility with `curl` for native support on Windows, macOS, and Linux. - No shell escaping issues, ensuring user prompts are passed directly. - Auto-download of generated images as `evolink-{timestamp}.webp`. - Configurable parameters for size, seed, and polling settings. - Standard Skill structure with progressive disclosure. Tech stack: Shell Why it matters: This skill allows for the generation of AI images through a straightforward and efficient process, leveraging the Evolink API without the need for additional dependencies or shell scripting. Repository: EvoLinkAI/OpenClaw-Image-Generator GitHub stars: 8 GitHub description: A Claude Code skill for generating images via the Evolink Z-Image-Turbo API. Cross-platform, zero dependencies.
Go 8 stars

FraiseHQ/fraise

In-memory knowledge store for AI agents

Overview: Fraise is a memory database designed specifically for AI agents, allowing them to query knowledge directly in a token-based language. Key features: - **Query Language**: Built for AI agents, allowing them to interact with the database in a language optimized for tokens rather than humans. - **In-Memory Storage**: Data is stored in memory, ensuring immediate access and high performance. - **No Infrastructure**: Runs entirely in memory, eliminating the need for any external infrastructure. Tech stack: Go. Why it matters: Fraise simplifies the interaction between AI agents and their knowledge, making it easier for them to retrieve information directly and quickly. Repository: FraiseHQ/fraise GitHub stars: 8 GitHub description: In-memory knowledge store for AI agents.
Jupyter Notebook 8 stars

GURPREETKAURJETHRA/Building-RAG-With-OpenAI-GPT-4o-omni-Model-Using-Objectbox-Vector-Database

Building RAG With OpenAI GPT-4o(omni) Model Using Objectbox Vector Database

### Overview: This project showcases the integration of OpenAI's GPT-4o model with an Objectbox Vector Database to create a highly efficient and natural RAG application. The model's ability to respond to various inputs and generate outputs in multiple formats makes it highly valuable for applications requiring comprehensive understanding and interaction. ### Key Features: - Utilizes OpenAI's GPT-4o model for creating a RAG application. - Integrates Objectbox Vector Database for efficient querying and storage of data. - Matches GPT-4o's performance on text and code, with significant improvements in non-English language understanding and faster response times. ### Tech Stack: Jupyter Notebook ### Why It Matters: GPT-4o’s ability to handle a wide range of inputs and generate outputs in multiple formats makes it a game-changer for applications requiring comprehensive understanding and interaction. Its superior performance in vision and audio understanding, along with its speed and cost-effectiveness, positions it as a leading model in natural language processing and beyond.
Python 8 stars

GeorgeVern/AFTERV1.0

Python source code for EMNLP 2020 Findings paper: "Domain Adversarial Fine-Tuning as an Effective Regularizer".

Overview: This repository contains Python source code for the EMNLP 2020 Findings paper titled "Domain Adversarial Fine-Tuning as an Effective Regularizer". The project proposes a new type of regularizer for fine-tuning pretrained language models to prevent catastrophic forgetting during the process. Key features: - Implementing a domain adversarial fine-tuning process - Using a gradient reversal layer to minimize the task-specific loss and maximize the loss of a domain classifier - Extending the standard fine-tuning process with an adversarial objective to preserve knowledge captured during pretraining Tech stack: Python Why it matters: This project demonstrates the effectiveness of domain adversarial fine-tuning as a regularizer, improving performance on various GLUE datasets compared to standard fine-tuning methods.
TypeScript 8 stars

GridLLM/MicroModel

Overview: MicroModel is a simple proxy server designed to forward OpenAI API requests and automatically save conversations as ChatML format, supporting per-workflow configuration. Key features: - Automatic workflow assignment based on port - Support for multiple workflows with different configurations - Saves conversations in ChatML format with automatic date-based organization Tech stack: TypeScript Why it matters: MicroModel simplifies the process of integrating OpenAI's API with a per-workflow configuration, making it easier to manage and analyze conversations for various workflows. Repository: GridLLM/MicroModel Primary language: TypeScript GitHub stars: 8 GitHub description: No description provided. README excerpt: # MicroModel A simple proxy server that forwards OpenAI API requests and automatically saves conversations as training data in ChatML format. Now supports per-workflow configuration with individual API hosts, keys, and ports. > [!NOTE] > Supports both `/v1/completions` and `/v1/chat/completions` endpoints. ## Quick Start 1. Clone and install: ```bash git clone https://github.com/GridLLM/MicroModel.git cd MicroModel npm install ``` 2. Create `config.json` file (required): ```json { "default": { "OPENAI_API_HOST": "http://localhost:11434", "API_KEY": "", "PORT": 3001 }, "custom_workflow": { "OPENAI_API_HOST": "http://localhost:11434",
Python 8 stars

Intelligent-Microsystems-Lab/SplitZip

SplitZip: Ultra Fast Lossless KV Compression for Disaggregated LLM Serving

Overview: SplitZip is a GPU-friendly lossless compressor designed specifically for KV cache transfer in disaggregated LLM serving. It preserves BF16 KV tensors bitwise while reducing transfer volume and maintains both compression and decompression on the latency-critical GPU path. Key features: - Lossless BF16 KV cache compression with bitwise round-trip recovery. - Offline-calibrated, Top-16 exponent codebooks with chunk-local sparse escape metadata. - GPU encode and decode kernels implemented in Triton. - Reproduction scripts for WikiText-2/Qwen3-32B exponent statistics and codec-path throughput measurements. Tech stack: Python Why it matters: SplitZip is optimized for GPU performance and provides a significant speedup over general-purpose compressors, making it ideal for real-time KV cache transfer in disaggregated LLM serving environments.
Swift 8 stars

JadenGeller/similarity-topology

Efficient nearest neighbor search in Swift

Overview: `similarity-topology` is a Swift library designed for efficient nearest neighbor searches in high-dimensional data using the Hierarchical Navigable Small World (HNSW) index. Key features: - HNSW Index: A multi-layer graph index for fast nearest neighbor searches. - Modules: Includes `HNSWAlgorithm` and `HNSWDurable` for both generic and durable storage implementations. Tech stack: Swift Why it matters: The HNSW index is crucial for applications requiring fast and efficient nearest neighbor searches in high-dimensional spaces, making it an essential tool for developers working with large datasets.
JavaScript 8 stars

JuneLearn/dsh-image2-draw

DeepSeek Harness Image2 生图插件,通过第三方 OpenAI Images 兼容接口调用 gpt-image-2,只需配置 baseURL 和 API Key。 | Image2 generation plugin for DeepSeek Harness via third-party OpenAI Images-compatible APIs.

### Overview: DeepSeek Harness Image2 生图插件,通过第三方 OpenAI Images 兼容接口调用 gpt-image-2,只需配置 baseURL 和 API Key。此插件允许开发者在 DeepSeek Harness 中生成图像,无需直接在 Harness 中生成图像。 ### Key features: - **Image2 Draw**: 添加一个“Image2 Draw”卡片到“Settings > Plugins > Configurable plugins”中。 - **仅需配置**:只需提供一个 `baseURL` 和一个 `API Key`,默认模型为 `gpt-image-2`。 - **自动后缀**:接受一个短的 `baseURL`,如 `https://example.com/v1`,并自动添加 `/images/generations`。 - **编辑端点**:生成图像编辑端点为 `/images/edits`,可选地通过 `editURL` 进行重写。 - **文本到图像**:提供 `image2-generate` 用于 1-8 个文本到图像的生成。 - **图像到图像**:提供 `image2-edit`,支持 1-8 个 PNG、JPEG 或 WebP 参考图像。 - **自适应尺寸**:支持适应性横竖屏和验证后的自定义尺寸。 - **直接显示**:在对话中直接显示生成的图像,使用专用工具卡片显示缩略图、放大和保存为操作。 - **无注入**:在客户端卡片中解析图像附件,不将图像内容注入
C++ 8 stars

Just1truc/kernel_lens

Deploy any research model right away

### Overview: KernelLens is a tool that compiles PyTorch models with custom `@triton.jit` kernels into native C++ artifacts for ONNX Runtime and NVIDIA TensorRT. It simplifies the process by generating zero-copy VRAM binding, enabling dynamic grids, and supports multiple TensorRT versions. ### Key features: - **Dual-pass tracing**: Captures PTX, shared memory, and strides; reconstructs dynamic launch grids. - **Automated plugin synthesis**: Generates `OrtCustomOp` and `IPluginV2DynamicExt` sources, compiling with `nvcc`/`g++`. - **Dynamic grids in C++**: Launch-grid expressions transpiled to C++ integer math, serving dynamic batch and sequence lengths. - **One package, several TensorRT versions**: Interface choice from environment, TensorRT 10+ emits `IPluginV3` plugins, TensorRT 11+ emits `IPluginV2DynamicExt` plugins. - **Shape-generic engines**: Leading dimension as a symbolic axis, serving any size in a declared range via a TensorRT optimization profile. - **Zero-copy VRAM binding**: PyTorch `data_ptr()` values registered directly with each engine, no host staging copies. - **Blackwell PTX ISA clamping**: Triton-generated `.version 9.3` header rewritten to `.version 9.0` for CUDA driver JIT. - **FP8 & sub-byte INT4**: 1-byte pointer mapping and dtype-accurate in-place copies. - **Cold-start detection**: Detect