3 Agenten. 3 LLMs. 1 alternde GPU: Parallele Inferenz auf Bare Metal entwickeln

3 Agents. 3 LLMs. 1 alternde GPU: Parallele Inferenz auf Bare Metal entwickeln

Der Aufstieg von Multi-Agenten-KI-Systemen bringt eine neue Herausforderung mit sich: Wie betreibt man drei unabhängige LLM-Agenten gleichzeitig auf einer einzigen, alternden GPU, ohne auf Cloud-Offloading zurückzugreifen? Dieser Artikel beschreibt die praktische Entwicklung paralleler Inferenz auf Bare Metal – nur mit der Hardware, die Sie bereits besitzen. Wir behandeln Anforderungen, Schritt-für-Schritt-Installation und konkrete Anwendungsbeispiele – alles auf einer einzigen GPU, die schon bessere Tage gesehen hat.

Warum parallele Inferenz wichtig ist

Moderne KI-Workflows setzen zunehmend auf mehrere Agenten, die zusammenarbeiten – einer für logisches Denken, einer für Informationsabruf, einer für kreative Generierung. Werden sie nacheinander auf einer GPU ausgeführt, verschwendet das Zeit und Speicher. Bei paralleler Inferenz, bei der jeder Agent gleichzeitig Tokens streamt, können Latenzzeiten reduziert und der Durchsatz verbessert werden. Auf einer alternden GPU (denken Sie an GTX 1080 Ti oder RTX 2060) müssen Sie jedoch Speicher, Modellgrößen und Terminplanung sorgfältig verwalten.

Wie in aktuellen Branchendiskussionen festgestellt, unter anderem in Berichten von OpenAI News und Microsoft AI Blog, macht der Trend zu kleineren, spezialisierten Modellen dies machbar. Anthropic News hat ebenfalls hervorgehoben, dass effiziente Inferenz der Schlüssel zur Demokratisierung von KI ist. Diese Anleitung setzt diese Ideen in die Praxis um.

Anforderungen

Bevor wir beginnen, definieren wir die Hardware- und Software-Basis.

Hardware

• **GPU**: NVIDIA GTX 1080 Ti (11 GB VRAM) oder ähnlich. Alles mit 8+ GB VRAM funktioniert.
• **CPU**: Jeder moderne Prozessor mit 4+ Kernen.
• **RAM**: 32 GB Systemspeicher (16 GB Minimum).
• **Speicher**: 50 GB frei für Modelle und Code.

Software

• **Betriebssystem**: Ubuntu 22.04 LTS (oder jedes Linux mit NVIDIA-Treibern).
• **NVIDIA-Treiber**: Version 525 oder höher.
• **CUDA Toolkit**: 12.1 (kompatibel mit Ihrem Treiber).
• **Python**: 3.10 oder 3.11.

Modelle

Wir verwenden drei kleine, aber leistungsfähige LLMs: 1. **Agent 1**: `microsoft/phi-3-mini-4k-instruct` (3,8 Mrd. Parameter, ~2,2 GB in 4-Bit) 2. **Agent 2**: `TinyLlama/TinyLlama-1.1B-Chat-v1.0` (1,1 Mrd. Parameter, ~0,7 GB) 3. **Agent 3**: `google/gemma-2-2b-it` (2 Mrd. Parameter, ~1,2 GB in 4-Bit)

Gesamter VRAM-Verbrauch: ~4 GB, sodass Spielraum für KV-Caches und gleichzeitige Ausführung bleibt.

Schritt-für-Schritt-Installation

Wir richten eine Bare-Metal-Umgebung mit minimalem Overhead ein. Kein Docker, keine Cloud – nur reine Inferenz.

1. Systemabhängigkeiten installieren

Aktualisieren Sie zunächst Ihr System und installieren Sie wichtige Werkzeuge.

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential git curl wget python3-pip python3-venv

2. NVIDIA-Treiber und CUDA installieren

Wenn Sie den NVIDIA-Treiber noch nicht installiert haben, tun Sie dies jetzt.

# GPU und Treiberversion prüfen
nvidia-smi
# Falls nicht installiert, Ubuntu-Treiberinstaller verwenden
sudo ubuntu-drivers autoinstall
sudo reboot

Nach dem Neustart CUDA 12.1 installieren (Download von NVIDIA). Hier eine minimale Installation:

wget https://developer.download.nvidia.com/compute/cuda/12.1.0/local_installers/cuda_12.1.0_530.30.02_linux.run
sudo sh cuda_12.1.0_530.30.02_linux.run --silent --toolkit

CUDA zum PATH hinzufügen:

echo 'export PATH=/usr/local/cuda-12.1/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.1/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

3. Python-Umgebung einrichten

Erstellen Sie eine virtuelle Umgebung, um Abhängigkeiten zu isolieren.

python3 -m venv llm_agents_env
source llm_agents_env/bin/activate

4. Inferenzbibliotheken installieren

Wir verwenden `transformers` mit `bitsandbytes` für 4-Bit-Quantisierung und `vllm` für effiziente parallele Terminplanung.

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install transformers accelerate bitsandbytes
pip install vllm

`vllm` ist entscheidend: Es unterstützt kontinuierliches Batching, sodass mehrere Anfragen gleichzeitig auf einer GPU verarbeitet werden können.

5. Modelle herunterladen

Wir speichern alle drei Modelle lokal zwischen.

# Verzeichnis für Modelle erstellen
mkdir -p ~/models

# Jedes Modell mit einem Python-Einzeiler herunterladen
python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('microsoft/phi-3-mini-4k-instruct', device_map='auto', load_in_4bit=True); \
tokenizer = AutoTokenizer.from_pretrained('microsoft/phi-3-mini-4k-instruct'); \
model.save_pretrained('~/models/phi-3-mini'); \
tokenizer.save_pretrained('~/models/phi-3-mini')"

python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0', device_map='auto', load_in_8bit=True); \
tokenizer = AutoTokenizer.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0'); \
model.save_pretrained('~/models/tinyllama'); \
tokenizer.save_pretrained('~/models/tinyllama')"

python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b-it', device_map='auto', load_in_4bit=True); \
tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b-it'); \
model.save_pretrained('~/models/gemma-2-2b'); \
tokenizer.save_pretrained('~/models/gemma-2-2b')"

Dies kann je nach Internetgeschwindigkeit 10–20 Minuten dauern.

Parallele Inferenz entwickeln

Jetzt bauen wir das Kernsystem: drei Agenten, die jeweils ein anderes LLM ausführen, alle auf derselben GPU.

Die Architektur

Wir verwenden den asynchronen API-Server von `vllm`. Jeder Agent ist ein separater Client, der gleichzeitig Prompts sendet. Der Server bündelt sie intelligent.

Konfigurationsdatei

Erstellen Sie `config.json` in Ihrem Projektverzeichnis:

{
  "models": [
    {
      "name": "phi-3-mini",
      "model_path": "~/models/phi-3-mini",
      "port": 8001,
      "max_num_seqs": 4,
      "gpu_memory_utilization": 0.3
    },
    {
      "name": "tinyllama",
      "model_path": "~/models/tinyllama",
      "port": 8002,
      "max_num_seqs": 6,
      "gpu_memory_utilization": 0.2
    },
    {
      "name": "gemma-2-2b",
      "model_path": "~/models/gemma-2-2b",
      "port": 8003,
      "max_num_seqs": 4,
      "gpu_memory_utilization": 0.3
    }
  ]
}

Hinweis: Die `gpu_memory_utilization`-Anteile ergeben 0,8, sodass 0,2 für Overhead bleiben.

Server starten

Erstellen Sie `start_agents.sh`:

#!/bin/bash
source llm_agents_env/bin/activate

# vllm-Server für jedes Modell im Hintergrund starten
python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/phi-3-mini \
    --port 8001 \
    --max-num-seqs 4 \
    --gpu-memory-utilization 0.3 \
    --trust-remote-code &

python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/tinyllama \
    --port 8002 \
    --max-num-seqs 6 \
    --gpu-memory-utilization 0.2 \
    --trust-remote-code &

python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/gemma-2-2b \
    --port 8003 \
    --max-num-seqs 4 \
    --gpu-memory-utilization 0.3 \
    --trust-remote-code &

# Auf alle Hintergrundprozesse warten
wait

Machen Sie es ausführbar und führen Sie es aus:

chmod +x start_agents.sh
./start_agents.sh

Jeder Server hört auf einem anderen Port. Sie teilen sich dieselbe GPU über die Speicherverwaltung von `vllm`.

Client-Code für parallele Anfragen

Erstellen Sie nun `run_agents.py`, um gleichzeitig Prompts an alle drei Agenten zu senden:

import asyncio
import aiohttp
import time

async def query_agent(session, url, prompt, agent_name):
    payload = {
        "model": agent_name,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 200,
        "temperature": 0.7
    }
    start_time = time.time()
    async with session.post(url, json=payload) as resp:
        result = await resp.json()
        elapsed = time.time() - start_time
        content = result["choices"][0]["message"]["content"]
        print(f"[{agent_name}] Zeit: {elapsed:.2f}s")
        print(f"[{agent_name}] Antwort: {content[:100]}...")
        return content

async def main():
    prompts = {
        "phi-3-mini": "Erkläre Quantencomputing in einfachen Worten.",
        "tinyllama": "Schreibe ein Haiku über eine Katze.",
        "gemma-2-2b": "Was ist die Hauptstadt von Frankreich? Erkläre kurz."
    }
    
    urls = {
        "phi-3-mini": "http://localhost:8001/v1/chat/completions",
        "tinyllama": "http://localhost:8002/v1/chat/completions",
        "gemma-2-2b": "http://localhost:8003/v1/chat/completions"
    }
    
    async with aiohttp.ClientSession() as session:
        tasks = []
        for agent_name, prompt in prompts.items():
            task = query_agent(session, urls[agent_name], prompt, agent_name)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
        print("\n=== Alle Agenten abgeschlossen ===")
        return results

if __name__ == "__main__":
    asyncio.run(main())

Führen Sie es aus:

python3 run_agents.py

Sie sollten alle drei Antworten mit überlappenden Zeiten sehen – ein Beweis für parallele Inferenz.

Anwendungsbeispiele

Beispiel 1: Multi-Agenten-Logik

Kombinieren Sie Agenten für eine Gedankenkette. Zum Beispiel erstellt Agent 1 einen Plan, Agent 2 ruft Fakten ab, Agent 3 synthetisiert die Antwort.

Ändern Sie `run_agents.py`, um Ausgaben sequentiell zu übergeben, aber mit parallelem Modell-Laden:

# Nach Erhalt des Plans von phi-3-mini an tinyllama für Fakten übergeben
plan = results[0]
fact_prompt = f"Basierend auf diesem Plan: {plan}, liste wichtige Fakten auf."
# ... mit Pipeline fortfahren

Beispiel 2: Auslastungstest

Senden Sie 10 gleichzeitige Anfragen an jeden Agenten, um Ihre GPU zu stressen:

async def stress_test(agent_name, url, num_requests=10):
    async with aiohttp.ClientSession() as session:
        tasks = [query_agent(session, url, "Hallo, wer bist du?", agent_name) 
                 for _ in range(num_requests)]
        await asyncio.gather(*tasks)

Auf einer GTX 1080 Ti sehen Sie einen Durchsatz von 5–10 Token/Sekunde pro Agent, abhängig von der Modellgröße.

Beispiel 3: GPU-Auslastung überwachen

Überwachen Sie während des Betriebs den VRAM in einem anderen Terminal:

watch -n 1 nvidia-smi

Sie werden sehen, dass die VRAM-Auslastung bei etwa 8–9 GB liegt, wobei alle drei Modelle geladen sind.

Fehlerbehebung

Speicherfehler

Wenn der VRAM nicht ausreicht, reduzieren Sie `gpu_memory_utilization` in der Konfiguration oder verwenden Sie kleinere Modelle (z. B. phi-3 durch ein 1B-Modell ersetzen).

CUDA-Fehler

Stellen Sie sicher, dass Ihr Treiber zu CUDA 12.1 passt. Führen Sie aus:

nvidia-smi | grep "CUDA Version"

Langsame Inferenz

Auf einer alternden GPU sind 2–5 Token/Sekunde pro Agent zu erwarten. Das ist normal. Optimieren Sie durch Reduzierung von `max_tokens` oder Verwendung von 4-Bit-Quantisierung.

Fazit

Drei LLM-Agenten auf einer einzigen alternden GPU zu betreiben, ist nicht nur möglich – es ist praktikabel. Mit sorgfältiger Modellauswahl (kleine Modelle, 4-Bit-Quantisierung), einem leistungsfähigen Scheduler wie `vllm` und Bare-Metal-Konfiguration können Sie parallele Inferenz ohne Cloud-Ressourcen erreichen. Dieses Setup ist ideal für Hobbyisten, Forscher oder alle, die mit Multi-Agenten-Systemen experimentieren möchten – und das mit kleinem Budget.

Wie vom Microsoft AI Blog und Anthropic News betont, liegt die Zukunft der KI in effizienter, gerätebasierter Inferenz. Durch die Entwicklung unter Berücksichtigung von Beschränkungen erschließen Sie die Kraft mehrerer Agenten, ohne Ihr Budget zu sprengen. Jetzt bauen Sie etwas mit Ihren drei Agenten und einer müden GPU.