awesome-repositories.com
Blog
MCP
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
llm-d avatar

llm-d/llm-d

0
View on GitHub↗
2,514 estrellas·324 forks·Shell·apache-2.0·9 vistaswww.llm-d.ai↗

Llm D

llm-d is a distributed serving framework designed for large language model inference. It functions as an inference orchestrator and gateway, providing a control plane for deploying model replicas and managing hardware accelerators. The system includes a batch inference scheduler and a cache manager to coordinate request flow and memory utilization.

The project is distinguished by a disaggregated serving architecture that separates prefill and decode execution phases across specialized workers to maximize throughput. It employs a hardware-agnostic control plane and tiered cache offloading, moving memory blocks between GPU memory, host RAM, and shared storage to support long-context workloads.

The framework covers comprehensive traffic management and scaling capabilities, including SLO-aware autoscaling, cache-affinity routing, and predictive latency scoring. It also provides mechanisms for offline batch processing and high-availability scheduler management to balance interactive traffic with asynchronous workloads.

The system exposes these capabilities via an OpenAI-compatible chat completion API.

Features

  • Disaggregated Inference Orchestration - Provides a distributed architecture that separates prefill and decode phases across specialized worker pools to maximize throughput.
  • Disaggregated Inference - Implements a disaggregated architecture that separates prefill and decode phases across specialized hardware nodes to maximize throughput.
  • Disaggregated Throughput Optimizations - Provides a disaggregated prefill and decode topology specifically designed to maximize throughput for batch-intensive LLM workloads.
  • Hardware-Agnostic Accelerators - Utilizes a hardware-agnostic control plane to manage various accelerators and enable low-latency inter-chip communication.
  • Inference Gateways - Functions as an OpenAI-compatible API gateway for request routing and traffic distribution.
  • KV Cache Management - Optimizes prefix reuse through cache-aware routing and tiered offloading of memory blocks.
  • KV-Cache-Aware Request Routing - Employs a weighted scoring system to route requests to replicas holding the necessary KV cache context.
  • Prefix Cache Reuse - Maximizes cache hits by tracking state across servers and offloading excess data to secondary storage.
  • Inference Deployment Orchestrators - Provides a control plane for deploying model replicas and managing hardware accelerators with SLO-aware scaling.
  • Agnostic Control Planes - Provides a hardware-agnostic control plane to manage diverse accelerators and ensure low-latency communication across different chips.
  • OpenAI-Compatible Model Servers - Provides an OpenAI-compatible API gateway for drop-in integration of large language model inference services.
  • Prefix-Aware Routing - Routes incoming traffic to specific model replicas based on cached prompt prefixes to minimize redundant computation.
  • LLM KV Cache Stores - Optimizes memory use and prefix reuse by offloading KV caches to CPU or shared storage and routing via affinity.
  • Inference Batching - Manages large volumes of offline inference requests through queuing and flow control to maximize hardware utilization.
  • LLM Replica Autoscaling - Automatically adjusts the number of model replicas based on queue depth and memory pressure to maintain latency targets.
  • Model Deployments - Deploys and manages multiple instances of model replicas on hardware accelerators for scalable request processing.
  • Traffic Load Balancers - Provides a proxy-based distribution system to balance incoming model traffic across multiple server replicas.
  • Cache-Aware Load Balancing - Distributes inference requests across server pools using real-time metrics, predicted latency, and cache locality.
  • Memory Offloading Frameworks - Implements tiered cache offloading by moving memory blocks between GPU memory, host RAM, and shared storage for long-context workloads.
  • Latency Reduction Techniques - Implements a performance suite using speculative decoding and fused kernels to minimize token generation latency.
  • Activation and KV Cache Offloaders - Swaps memory blocks to host RAM to prevent context drops during long-context workloads.
  • Shared Storage Offloading - Moves memory blocks to a shared file system to decouple cache capacity from local GPU memory.
  • Cache-Aware Schedulers - Implements a scheduling system that leverages shared context and prefix caching to optimize throughput for multi-tenant environments.
  • KV-Cache Transport Optimizations - Reduces tail latency during context migration using adaptive congestion control and specialized libraries.
  • Asynchronous Batching Execution - Executes latency-tolerant requests from message queues to maximize hardware utilization alongside interactive traffic.
  • Disaggregated Phase Scaling - Scales large models by separating prefill and decode stages using expert parallelism.
  • Adapter-Aware Routing - Routes traffic to specific nodes based on the location of loaded LoRA adapters to avoid redundant execution.
  • Offline Batch Inference - Provides a mechanism to run large-scale asynchronous inference via compatible APIs to maximize total hardware utilization.
  • SLO-Driven Predictive Routing - Scores endpoints by predicting time-to-first-token and inter-token latency to ensure requests meet defined performance targets.
  • Disaggregated Serving - Utilizes a disaggregated architecture to split prefill and decode stages across fast accelerator interconnects.
  • Saturation-Based Scaling - Reactive optimizer that adjusts the number of replicas by monitoring queue length to prevent request overflow.
  • Asynchronous Gating - Implements flow-control gating to execute offline batch requests using spare hardware capacity.
  • Pressure-Based Scaling - Adjusts the number of active replicas by monitoring cache saturation and queue length to maintain system stability.
  • Capacity Scaling - Adjusts compute resources using native metrics and traffic routing to minimize costs while meeting latency targets.
  • Queue-Based Scaling Triggers - Handles traffic spikes using intelligent queuing and autoscales capacity based on real-time load metrics.
  • Scheduler High Availability - Ensures redundancy and accurate cache tracking through a high-availability scheduler that discovers server pods.
  • SLO-Aware Scaling - Implements production stability through SLO-aware autoscaling and flow control for multi-tenant environments.
  • Inference Job Management - Provides capabilities to queue offline requests and dispatch them using flow-control gating for high-volume workloads.
  • Pod Autoscaling - Autoscales container replicas by monitoring queue depth and memory saturation to maintain latency targets.
  • LLM Production Infrastructure - Sets up and manages high-availability infrastructure specifically designed for production LLM serving.
  • Cold-Start Load Balancing - Provides a specialized distribution strategy for cache-cold requests to prevent hotspots and oscillations in the request queue.
  • Load Balancing Metrics - Distributes requests across replicas using real-time queue depth and memory saturation metrics.
  • Predictive Latency Routing - Implements a routing system that predicts time-to-first-token and inter-token latency to enforce performance targets.
  • SLO-Based Server Placement - Ships a request packing system that compares predicted latency against defined SLO targets to optimize server placement.
  • Inference Batching Schedulers - Provides a request queuing system that balances interactive traffic with asynchronous offline workloads.

Historial de estrellas

Gráfico del historial de estrellas de llm-d/llm-dGráfico del historial de estrellas de llm-d/llm-d

Búsqueda con IA

Explora más repositorios increíbles

Describe lo que necesitas en lenguaje sencillo: la IA clasifica miles de proyectos open-source curados por relevancia.

Start searching with AI

Preguntas frecuentes

¿Qué hace llm-d/llm-d?

llm-d is a distributed serving framework designed for large language model inference. It functions as an inference orchestrator and gateway, providing a control plane for deploying model replicas and managing hardware accelerators. The system includes a batch inference scheduler and a cache manager to coordinate request flow and memory utilization.

¿Cuáles son las características principales de llm-d/llm-d?

Las características principales de llm-d/llm-d son: Disaggregated Inference Orchestration, Disaggregated Inference, Disaggregated Throughput Optimizations, Hardware-Agnostic Accelerators, Inference Gateways, KV Cache Management, KV-Cache-Aware Request Routing, Prefix Cache Reuse.

¿Qué alternativas de código abierto existen para llm-d/llm-d?

Las alternativas de código abierto para llm-d/llm-d incluyen: ai-dynamo/dynamo — Dynamo is a distributed inference orchestration platform designed for large language models. It functions as a system… kvcache-ai/mooncake — Mooncake is a disaggregated large language model serving platform and distributed key-value store designed for… vllm-project/aibrix — Aibrix is an inference orchestrator designed for scaling, routing, and managing the deployment of large language… paddlepaddle/fastdeploy — FastDeploy is a high-performance deployment framework for large language models, vision models, and multimodal models.… kubeflow/kfserving — KServe is an open platform for deploying and serving generative and predictive AI models on Kubernetes. It defines… pytorch/serve — This project is a PyTorch model serving framework designed to deploy and scale machine learning models in production…

Alternativas open-source a Llm D

Proyectos open-source similares, clasificados según cuántas características comparten con Llm D.
  • ai-dynamo/dynamoAvatar de ai-dynamo

    ai-dynamo/dynamo

    6,112Ver en GitHub↗

    Dynamo is a distributed inference orchestration platform designed for large language models. It functions as a system to coordinate prefill and decode phases across GPU nodes, utilizing a multi-backend runtime adapter to connect engines like vLLM and TensorRT-LLM through a unified block-oriented memory interface. An OpenAI-compatible API server provides the frontend for integration with existing tools and clients. The project is distinguished by its disaggregated serving architecture, which separates prompt processing and token generation onto independent GPU pools to optimize throughput and

    Rust
    Ver en GitHub↗6,112
  • kvcache-ai/mooncakeAvatar de kvcache-ai

    kvcache-ai/Mooncake

    5,594Ver en GitHub↗

    Mooncake is a disaggregated large language model serving platform and distributed key-value store designed for high-performance inference infrastructure. It functions as a GPU memory orchestrator and KV cache management system that pools and transfers key-value caches across clusters to accelerate inference. The system distinguishes itself by separating the prefill and decode phases of inference into distinct hardware clusters to optimize resource utilization. It utilizes a high-performance RDMA distributed cache with zero-copy transfers to move data between compute nodes, bypassing the CPU t

    C++
    Ver en GitHub↗5,594
  • vllm-project/aibrixAvatar de vllm-project

    vllm-project/aibrix

    4,882Ver en GitHub↗

    Aibrix is an inference orchestrator designed for scaling, routing, and managing the deployment of large language models across distributed vLLM clusters. It serves as a centralized gateway for load balancing and routing traffic to specific model replicas and versions. The system manages resource efficiency through a GPU cluster autoscaler that adjusts compute instance counts based on real-time request volume. It further optimizes operations by mixing different accelerator types within a single cluster and utilizing a model adapter orchestrator to deploy lightweight parameter adapters on share

    Go
    Ver en GitHub↗4,882
  • paddlepaddle/fastdeployAvatar de PaddlePaddle

    PaddlePaddle/FastDeploy

    3,700Ver en GitHub↗

    FastDeploy is a high-performance deployment framework for large language models, vision models, and multimodal models. It provides the infrastructure to launch model services that process combined image, video, and text inputs, exposing these capabilities through a standardized, OpenAI-compatible API for chat and text completions. The project distinguishes itself through advanced inference pipeline engineering and GPU optimization. It employs speculative decoding, tensor parallelism, and a disaggregated execution model that separates prefill and decode phases across different hardware resourc

    Pythonernieernie-45ernie-45-vl
    Ver en GitHub↗3,700
Ver las 30 alternativas a Llm D→