PegaFlow: o motor de armazenamento chave-valor em Rust com bindings Python para acelerar inferência de LLMs com vLLM

O que é o PegaFlow e por que ele importa para quem trabalha com LLMs

Quem já colocou um modelo de linguagem grande em produção sabe que a latência de inferência é um dos maiores gargalos operacionais. Cada token gerado depende de cálculos que, sem um sistema eficiente de cache, precisam ser refeitos do zero a cada requisição. É exatamente nesse ponto que entra o PegaFlow, uma biblioteca publicada no PyPI sob o nome pegaflow-llm-cu13, que chegou à versão 0.23.5 em julho de 2026.

A proposta central do projeto é simples de enunciar, mas complexa de executar bem: oferecer um motor de armazenamento chave-valor de alta performance, escrito em Rust e exposto ao ecossistema Python por meio do PyO3, com integração nativa ao vLLM — um dos frameworks de inferência distribuída mais adotados atualmente para servir modelos como LLaMA, Qwen e GPT-2.

A escolha do Rust como núcleo do projeto

A decisão de implementar o núcleo do PegaFlow em Rust não é novidade no ecossistema Python de alta performance. Projetos como Polars, Pydantic v2 e Ruff já demonstraram que combinar a ergonomia do Python com a velocidade e segurança de memória do Rust é uma estratégia sólida para bibliotecas que precisam lidar com grandes volumes de dados ou operar em ambientes de baixa latência.

No caso do PegaFlow, a escolha se justifica ainda mais: armazenamento de blocos de KV cache envolve operações de leitura e escrita extremamente frequentes, muitas vezes em paralelo, sobre tensores que podem ocupar gigabytes de memória GPU. Rust elimina a sobrecarga do garbage collector e oferece controle preciso sobre alocação de memória, características essenciais para esse tipo de carga de trabalho.

A ponte entre Rust e Python é feita pelo PyO3, uma biblioteca madura que permite expor structs e funções Rust diretamente como módulos Python, e o empacotamento é gerenciado pelo Maturin, ferramenta padrão de facto para projetos Python/Rust que precisam gerar wheels compatíveis com o ecossistema PyPI.

PegaEngine: armazenamento KV simples e eficiente

A interface mais básica do PegaFlow é a PegaEngine, uma abstração de armazenamento chave-valor que qualquer desenvolvedor Python consegue usar em minutos. A API é deliberadamente minimalista:

• put(chave, valor): persiste um par chave-valor no motor
• get(chave): recupera o valor associado, retornando None se a chave não existir
• remove(chave): remove a entrada e retorna o valor que estava armazenado

Essa simplicidade na superfície esconde uma implementação Rust que prioriza throughput e segurança em acesso concorrente. Para casos de uso gerais de armazenamento em memória com bindings Python, a PegaEngine já é uma alternativa interessante a soluções como dicionários Python puros ou wrappers sobre RocksDB.

PegaKVConnector: integração profunda com vLLM para cache distribuído

O componente mais sofisticado — e provavelmente o principal motivo de interesse do projeto para engenheiros de ML em produção — é o PegaKVConnector. Ele implementa a interface de KV transfer connector do vLLM, permitindo que blocos de KV cache computados durante a inferência sejam salvos no PegaFlow e reutilizados em requisições futuras, potencialmente em nós diferentes de um cluster distribuído.

Na prática, isso significa que se um prompt longo foi processado uma vez e seus blocos de KV cache foram armazenados, uma requisição subsequente com o mesmo prefixo de prompt pode pular o estágio de prefill para aqueles blocos — uma técnica conhecida como prefix caching — reduzindo drasticamente o tempo de resposta e o consumo de GPU.

Modos de operação do conector

O PegaKVConnector suporta dois modos distintos, configuráveis via parâmetro pegaflow.mode:

• read_write (padrão): o conector tanto consulta o PegaFlow em busca de blocos reutilizáveis quanto persiste os blocos recém-computados de volta ao armazenamento.
• save_only: o conector apenas persiste blocos, sem realizar consultas ou carregamentos. Esse modo é projetado para cenários com MultiConnector, onde outro conector é responsável pela leitura e o PegaFlow atua como camada de persistência secundária.

Essa flexibilidade é especialmente relevante em arquiteturas de inferência distribuída com separação entre estágios de prefill e decode (o chamado modelo P/D disaggregation), que vem ganhando espaço em deployments de larga escala para reduzir contenção de recursos entre as duas fases de geração.

Suporte a blocos parciais de tail em deployments P/D

Um detalhe técnico notável na documentação do PegaFlow é o suporte a partial tail blocks em arquiteturas P/D. Normalmente, o vLLM só expõe hashes para blocos de KV cache completos. O PegaFlow introduz os parâmetros pegaflow.pd_tail_save (no nó de prefill) e pegaflow.pd_tail_load (no nó de decode) para permitir o reaproveitamento do bloco final parcial do prompt — aquele que não preenche completamente o tamanho de bloco configurado.

Para garantir consistência de hashing entre os dois processos vLLM, é necessário definir o mesmo valor de PYTHONHASHSEED e usar o algoritmo xxhash_cbor para prefix caching. O parâmetro pegaflow.wait_for_full_prefix no lado do decode faz o processo aguardar até 30 segundos para que o prefixo completo do prompt esteja disponível via MetaServer e RDMA — uma indicação de que o projeto já contempla infraestrutura de transferência de tensores via rede de alta velocidade.

Compatibilidade e distribuição

A versão 0.23.5 do pegaflow-llm-cu13 está disponível como wheels pré-compiladas para CPython 3.10, 3.11, 3.12, 3.13 e 3.14, todas voltadas para Linux x86-64 com glibc 2.34 ou superior (padrão manylinux). O sufixo cu13 no nome do pacote indica compatibilidade com CUDA 13, o que alinha o projeto com as versões mais recentes do toolkit NVIDIA.

Cada wheel tem aproximadamente 7,9 MB, tamanho condizente com uma biblioteca que embute código Rust compilado e provavelmente dependências de runtime relacionadas a CUDA. A ausência de distribuição de código-fonte (sdist) no PyPI sugere que o projeto ainda não está preparado para compilação em ambientes arbitrários sem as dependências corretas de CUDA e Rust.

O projeto está classificado como Development Status: Alpha, o que é honesto para uma biblioteca que ainda está evoluindo rapidamente — a sequência de versões no histórico de releases mostra um ritmo de desenvolvimento intenso, com múltiplas versões lançadas por mês desde abril de 2026.

Como instalar e testar o PegaFlow

A instalação direta via pip é simples para quem já tem um ambiente CUDA 13 configurado:

pip install pegaflow-llm-cu13

Para quem prefere compilar a partir do código-fonte — o que permite modificar o código Rust e experimentar com a API de baixo nível — o processo envolve instalar o Maturin, compilar a extensão Rust e, opcionalmente, compilar o binário do servidor pegaflow-server com Cargo. Os testes de integração exigem uma GPU disponível, o que reflete a natureza do projeto como uma ferramenta voltada especificamente para ambientes de inferência com acelerador.

Por que acompanhar esse projeto

O PegaFlow representa uma tendência crescente no ecossistema de IA em produção: a necessidade de infraestrutura de baixo nível, de alta performance e fortemente tipada para suportar os sistemas de serving de LLMs que estão saindo dos experimentos e entrando em ambientes críticos. A combinação de Rust para o núcleo de armazenamento, PyO3 para a bridge com Python e integração nativa com vLLM posiciona o projeto como uma peça de infraestrutura relevante para equipes que operam clusters de inferência em escala.

Ainda em estágio alpha, o PegaFlow merece atenção de engenheiros de ML e desenvolvedores que trabalham com otimização de inferência distribuída — especialmente aqueles que já utilizam vLLM e estão buscando formas de reduzir latência e custo computacional via prefix caching e transferência eficiente de KV cache entre nós.