Brunobkr/llama.cpp_AlgMor24_github

ΩFFFΣLLIa • llama.cpp • AlgMor24

<div align="center">

   ██████╗ ███████╗███████╗███████╗██╗     ██╗     ██╗ █████╗ 
  ██╔═══██╗██╔════╝██╔════╝██╔════╝██║     ██║     ██║██╔══██╗
  ██║   ██║█████╗  █████╗  █████╗  ██║     ██║     ██║███████║
  ██║   ██║██╔══╝  ██╔══╝  ██╔══╝  ██║     ██║     ██║██╔══██║
  ╚██████╔╝██║     ██║     ███████╗███████╗███████╗██║██║  ██║
   ╚═════╝ ╚═╝     ╚═╝     ╚══════╝╚══════╝╚══════╝╚═╝╚═╝  ╚═╝

<b>High-Performance LLM / VLM Inference & Autonomous Agentic Ecosystem in Pure C/C++</b>

    

</div>

📖 Visão Geral

ΩFFFΣLLIa • llama.cpp • AlgMor24 é um fork avançado, destravado e de alta performance do ecossistema llama.cpp. Este projeto integra inferência local de última geração em C/C++ com um motor agêntico autônomo multi-turn, suporte nativo a FIM (Fill-in-the-Middle) para geração e preenchimento de código, Speculative Decoding otimizado para programação, integração de ferramentas MCP (Model Context Protocol) e uma interface Web moderna em SvelteKit/Vite com a identidade visual Cyberpunk Neon Fire.

✨ Destaques e Capacidades do Fork

🤖 1. Centro de Controle Agêntico (Agent Control Center)

• —Painel Dedicado na Barra Lateral (`#/agents`): Interface profissional para gerenciar, parametrizar e alternar entre perfis agênticos especializados com 1 clique.
• —5 Perfis Agênticos Nativos:
• —💻 Code Architect: Engenheiro de software full-stack para refatoração cirúrgica de código, exploração de repositórios e testes em terminal.
• —⚡ DevOps & SysOps: Automação de sistemas Linux, execução de pipelines shell e diagnóstico de hardware/SO.
• —🔍 Deep Research: Exploração técnica aprofundada, síntese de repositórios e conectores MCP de busca web.
• —📊 Math & Data Analyst: Resolução algébrica e computação simbólica exata via sandbox com Nerdamer.
• —🤖 Universal Agent: Agente multiuso com todas as 9 ferramentas nativas e servidores MCP ativos simultaneamente.
• —Execução Livre e Desbloqueada: Loop multi-turno configurado para auto-aprovação de ferramentas, permitindo que os agentes operem de forma contínua e autônoma sem pausas ou bloqueios de permissão.

💻 2. Motor de Infilling e FIM (Fill-in-the-Middle) Nativo

• —Compatibilidade Total com OpenAI `/v1/completions`:
• —O parâmetro suffix é processado diretamente pelo backend, permitindo integração imediata com extensões de IDEs (como Continue.dev, Cursor, Tabby, VS Code e Neovim) sem necessidade de adaptadores.
• —Endpoint Especializado `POST /infill`:
• —Implementa o Repo-Level Context Pattern (<FIM_REP>, <FIM_SEP>, <FIM_PRE>, <FIM_SUF>, <FIM_MID>), injetando trechos de múltiplos arquivos abertos no projeto para completar código com máxima precisão sintática.

⚡ 3. Speculative Decoding Otimizado para Programação

• —Aceleração de 2x a 3.5x na Geração de Código:
• —Código-fonte possui alta previsibilidade sintática (palavras-chave, identações, delimitadores).
• —Parâmetros ajustados no core C++ (n_max = 8, p_min = 0.75) para capturar blocos e declarações inteiras por passo de rascunho.
• —Compatível com modelos rascunho leves (ex: Qwen2.5-Coder-0.5B auxiliando Qwen2.5-Coder-32B / DeepSeek-Coder).

🛠️ 4. Matriz de Ferramentas Nativas & Protocolo MCP

Todas as ferramentas vêm ativadas e selecionáveis offline por padrão:

🎨 5. Identidade Visual ΩFFFΣLLIa (Cyberpunk Fogo Neon)

• —Tema Universal: Aplicado por padrão em todas as portas (8080, 5173, etc.) e dispositivos móveis/desktop.
• —Paleta Harmônica de Alta Legibilidade:
• —--flame: Laranja Incandescente (#ff5400)
• —--ember: Vermelho Brasa (#ff2a00)
• —--gold: Ouro Fundido (#ffb703)
• —--eye: Ciano Elétrico (#00e5ff)
• —Fundo ultra-escuro com atmosfera CRT/Ember e renderizadores dedicados para diffs de código e streaming de terminal.

🚀 Como Compilar e Executar

1. Pré-requisitos

• —Compilador C++ moderno (GCC 11+, Clang 14+, ou MSVC 2022)
• —CMake 3.14+
• —Node.js 18+ e npm (para os assets da Web UI)

2. Compilação do llama-server (Backend + Web UI Embutida)

# 1. Compilar os assets de produção da Web UI
cd tools/ui
npm install
npm run build
cd ../..

# 2. Configurar o build CMake (exemplo com suporte a CPU e Server ativo)
cmake -B build -DLLAMA_BUILD_SERVER=ON -DCMAKE_BUILD_TYPE=Release

# 3. Compilar todos os binários (ou apenas o llama-server)
cmake --build build --config Release -j$(nproc)

Aceleração por Hardware (Backends de GPU):

• —NVIDIA (CUDA): cmake -B build -DGGML_CUDA=ON -DLLAMA_BUILD_SERVER=ON && cmake --build build --config Release -j$(nproc)
• —Vulkan: cmake -B build -DGGML_VULKAN=ON -DLLAMA_BUILD_SERVER=ON && cmake --build build --config Release -j$(nproc)
• —Apple Silicon (Metal): cmake -B build -DGGML_METAL=ON -DLLAMA_BUILD_SERVER=ON && cmake --build build --config Release -j$(nproc)

3. Executando o Servidor

# Iniciar o servidor HTTP com todas as tools e Web UI ativas
./build/bin/llama-server \
  -m /caminho/para/seu/modelo.gguf \
  --port 8080 \
  --ctx-size 8192 \
  -ngl 99

Abra seu navegador em http://localhost:8080 para acessar a Web UI com o Centro de Controle Agêntico, ou utilize a API OpenAI compatível em http://localhost:8080/v1.

4. Executando com Speculative Decoding para Código

# Executa o modelo principal junto com o modelo rascunho (Draft Model)
./build/bin/llama-server \
  -m Qwen2.5-Coder-32B-Instruct-Q4_K_M.gguf \
  -md Qwen2.5-Coder-0.5B-Instruct-Q8_0.gguf \
  --spec-draft-n-max 8 \
  --spec-draft-p-min 0.75 \
  --port 8080

🔌 Integração com Extensões de IDE (FIM / Code Autocomplete)

Configure seu plugin favorito (Continue.dev, Cursor ou Tabby) apontando para o llama-server:

Exemplo de Configuração no config.json do Continue.dev:

{
  "tabAutocompleteModel": {
    "title": "llama.cpp Infill",
    "provider": "openai",
    "model": "Qwen2.5-Coder",
    "apiBase": "http://localhost:8080/v1"
  }
}

O endpoint /v1/completions responderá automaticamente às requisições contendo prompt e suffix com alta velocidade.

📡 Referência Rápida de Endpoints da API

• —POST /v1/chat/completions: Chat conversacional compatível com OpenAI, suporte a tool calling estruturado e streaming SSE.
• —POST /v1/completions: Completions de texto e código com suporte a suffix (FIM).
• —POST /infill: Infilling de código com padrão de múltiplos arquivos de repositório (input_extra).
• —GET /tools: Lista de todas as ferramentas ativas e seus esquemas JSON Schema.
• —POST /tools: Execução direta de ferramentas de backend.
• —GET /v1/models: Lista de modelos carregados no servidor.
• —GET /props: Parâmetros e propriedades globais do servidor.
• —GET /slots: Monitoramento em tempo real do processamento de slots e geração de tokens.

📁 Estrutura do Repositório

llama.cpp_algmor24_v3/
├── common/                  # Infraestrutura compartilhada (args, sampling, speculative, Jinja)
├── grammars/                # Gramáticas formais GBNF (C, JSON, aritmética)
├── src/                     # Núcleo GGML/LLaMA em C++ (tensores, KV cache, samplers)
├── tools/
│   ├── server/              # Backend C++ do llama-server (HTTP, MCP proxy, FIM, /tools)
│   ├── ui/                  # Frontend Web UI (SvelteKit, Vite, Agents Hub, Cyberpunk Theme)
│   ├── cli/                 # Interface conversacional de terminal interativo
│   ├── quantize/            # Utilitário de quantização de modelos GGUF
│   └── llama-bench/         # Ferramenta de benchmark de processamento e geração
└── examples/                # Scripts de apoio e conversores de gramática

📜 Licença

Distribuído sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.

<div align="center"> <b>ΩFFFΣLLIa • llama.cpp • AlgMor24 — Inferência Local, Descentralizada e Sem Limites</b> </div>