Bereitstellen lokaler Agents überall mit LFM2.5-2.6B

Überall lokale Agenten einsetzen mit LFM2.5-2.6B

Agentische KI ist zum dominierenden Thema der modernen Softwareentwicklung geworden. Von den Roadmap-Updates von OpenAI über die Enterprise-KI-Ankündigungen von Microsoft bis hin zu den Arbeiten von Anthropic an toolnutzenden Modellen ist die Botschaft konsistent: Die Zukunft gehört Systemen, die planen, Tools aufrufen und autonom handeln können. Doch während ein Großteil dieses Fortschritts in großen Cloud-Rechenzentren stattfindet, vollzieht sich eine leisere Revolution – nämlich die Ausführung leistungsfähiger Agenten auf Hardware, die man tatsächlich besitzt.

Diese Revolution wird von kleinen, aber mächtigen Open-Weights-Modellen angetrieben. Das LFM2.5-2.6B-Modell, ein 2,6-Milliarden-Parameter-Fundamentmodell aus der LFM-Generation (Liquid Foundation Model), ist einer der interessantesten Beiträge in diesem Bereich. Vorgestellt auf dem Hugging Face Blog, soll es den idealen Kompromiss zwischen roher Leistung und Recheneffizienz abdecken. In diesem Artikel erfahren Sie, wie Sie dieses Modell in einen echten, funktionierenden lokalen Agenten verwandeln – Installation, Konfiguration und Anbindung für die Werkzeugnutzung –, sodass Sie autonome Helfer auf einem Laptop, einem kleinen Server oder sogar einem stromsparenden Edge-Gerät ausführen können.

Warum lokale Agenten wichtig sind

Bevor wir uns in die Mechanik stürzen, lohnt es sich zu fragen, warum man überhaupt einen lokalen Agenten haben möchte. Die großen KI-Labore haben Jahre damit verbracht, massive Frontier-Modelle mit enormen Kontextfenstern und ausgefeilten Tool-Calling-Fähigkeiten zu entwickeln. Diese Modelle sind beeindruckend, bringen jedoch Einschränkungen mit sich: Sie werden remote gehostet, erfordern eine Netzwerkverbindung, und Ihre Prompts werden auf Infrastruktur verarbeitet, die außerhalb Ihrer Kontrolle liegt.

Lokale Agenten lösen eine andere Reihe von Problemen. Wenn alles auf Ihrer Hardware läuft, verlassen Ihre Daten niemals Ihren Rechner – das ist wichtig für vertrauliche Geschäftsdokumente, Krankenakten und persönliche Gespräche. Lokale Bereitstellung beseitigt außerdem die Kosten pro Token für API-Zugriffe. Es gibt keinen Zähler, der läuft, wenn Sie Ihr eigenes Modell ausführen; die einzigen Kosten sind Strom und der Preis für die Hardware, die Sie bereits besitzen.

Dazu kommt die Latenz. Ein lokaler Agent kann Fragen beantworten und Tools in Millisekunden aufrufen, weil kein Roundtrip zu einem entfernten Rechenzentrum nötig ist. Für interaktive Automatisierung – Bots, die auf Tastenkürzel, Sensorauslöser oder Dateisystemereignisse reagieren – ist niedrige Latenz kein Luxus, sondern eine Notwendigkeit.

Schließlich ist da noch die Flexibilität. Ein lokal bereitgestellter Agent kann kontinuierlich feinabgestimmt, angepasst und neu programmiert werden, ohne gegen Rate-Limits oder Produktrichtlinien zu stoßen. Sie besitzen den gesamten Stack – von den Gewichten bis zum Inferenzcode.

Einführung in LFM2.5-2.6B

Die LFM2.5-Generation von Liquid Foundation Models wurde mit Effizienz als zentralem Designziel entwickelt. Die 2,6B-Variante – LFM2.5-2.6B – ist leichtgewichtig genug, um auf einer Consumer-GPU, einer modernen Laptop-CPU oder – entsprechend quantisiert – sogar auf einem Gerät der Raspberry-Pi-Klasse zu laufen.

Das Modell ist für agentische Workflows konzipiert: Es verarbeitet lange Gesprächskontexte, kann strukturierte Ausgaben wie JSON für Funktionsaufrufe erzeugen und ist bewusst so konfiguriert, dass im Speicher genügend Raum für die unterstützende Infrastruktur bleibt, die ein Agent benötigt – Tool-Schemas, Gesprächsverlauf und eine Ausführungsschleife. Da es offen auf Hugging Face verteilt wird, erhalten Sie die vollständigen Gewichte, den Tokenizer und die Modellkarte – das bedeutet, Sie sind nicht an ein proprietäres API-Format gebunden.

All das macht LFM2.5-2.6B zu einem Paradebeispiel für die Philosophie „Überall lokale Agenten einsetzen": klein genug, um portabel zu sein, leistungsfähig genug, um wirklich nützlich zu sein, und offen genug, um es in die Form zu bringen, die Ihr Workflow verlangt.

Voraussetzungen

Die genauen Anforderungen hängen davon ab, wie aggressiv Sie optimieren möchten, aber hier ist eine Basis, die für die meisten Leser funktioniert:

• **Python 3.10 oder neuer**, zusammen mit `pip` und einem Tool für virtuelle Umgebungen.
• **Ein Rechner mit mindestens 8 GB RAM** für CPU-Inferenz in voller Präzision. Für ein komfortables Erlebnis sind 16 GB RAM besser.
• **Eine GPU mit mindestens 4 GB VRAM**. NVIDIA-Karten sind dank CUDA- und `bitsandbytes`-Unterstützung am einfachsten. Apple Silicon ist über das Metal-Backend ebenfalls eine praktikable Option (PyTorch unterstützt es standardmäßig).
• **Git** installiert, um Hilfsrepositorys wie `llama.cpp` zu klonen.
• **Ein kostenloses Hugging-Face-Konto**, einschließlich eines Benutzerzugriffstokens, um das Modell herunterzuladen. Einige Modelle sind beschränkt; möglicherweise müssen Sie den Bedingungen auf der Modellkarte unter huggingface.co/models zustimmen, bevor Sie herunterladen können.

Wenn Sie nichts davon besitzen, aber einen Computer haben, machen Sie sich keine Sorgen – die gesamte Installation ist so ausgelegt, dass sie auf bescheidener Hardware funktioniert, und wir werden die Quantisierung als erstklassigen Schritt einbeziehen.

Schritt-für-Schritt-Installation

1. Eine isolierte Umgebung erstellen

Der erste Schritt besteht darin, eine frische Python-Virtual-Environment zu erstellen. Dies verhindert Abhängigkeitskonflikte mit anderen Projekten auf Ihrem Rechner.

python3 -m venv lfm-agent
source lfm-agent/bin/activate

Der Befehl `source` aktiviert die Umgebung; unter Windows ersetzen Sie ihn durch `lfm-agent\Scripts\activate`.

2. PyTorch und den Modell-Lade-Stack installieren

PyTorch ist das Deep-Learning-Framework, das das Modell ausführen wird. Wenn Sie eine NVIDIA-GPU haben, installieren Sie den CUDA-fähigen Build; andernfalls verwenden Sie den CPU-Build. Beide Befehle sind unten gezeigt.

pip install --upgrade pip
pip install torch --index-url https://download.pytorch.org/whl/cu121

Für reine CPU-Maschinen:

pip install torch --index-url https://download.pytorch.org/whl/cpu

Als Nächstes installieren Sie das Hugging-Face-Ökosystem: `transformers` ist unsere Haupt-Inferenzbibliothek, während `accelerate` die Geräteplatzierung übernimmt und `bitsandbytes` eine effiziente 4-Bit-Quantisierung ermöglicht.

pip install "transformers>=4.45.0" accelerate bitsandbytes huggingface_hub sentencepiece

3. Beim Hugging Face Hub authentifizieren

Viele offene Modelle, darunter auch einige aus der LFM-Familie, werden über den Hugging Face Hub verteilt und erfordern möglicherweise, dass Sie vor dem Download die Lizenzbedingungen anerkennen. Das Tool `huggingface-cli` ist bereits als Teil des Pakets `huggingface_hub` installiert. Melden Sie sich mit Ihrem Token an:

huggingface-cli login

Der Befehl fragt nach Ihrem Token, den Sie unter **Einstellungen → Zugriffstokens** auf hf.co erstellen. Nach der Eingabe wird das Token lokal zwischengespeichert und alle nachfolgenden Downloads verwenden es automatisch.

4. Die Modellgewichte herunterladen

Wir laden das Modell in ein lokales Verzeichnis herunter, damit wir mehrere verschiedene Inferenz-Backends mit denselben Dateien ausführen können. Denken Sie daran, `your-org` durch den tatsächlichen Namespace zu ersetzen, der auf der LFM2.5-2.6B-Modellkarte angezeigt wird.

from huggingface_hub import snapshot_download

repo_id = "your-org/LFM2.5-2.6B-instruct"
snapshot_download(repo_id=repo_id, local_dir="lfm2.5-2.6b-instruct")

Die Funktion `snapshot_download` bewahrt die exakte Repository-Struktur. Wenn Sie wenig Speicherplatz haben, können Sie `allow_patterns=["*.json", "*.safetensors"]` übergeben, um nicht wesentliche Dateien zu überspringen.

5. Das Modell mit Transformers laden

Hier ist ein minimales Skript, das das Modell in bfloat16 lädt und es mithilfe von `device_map="auto"` intelligent auf Ihrer Hardware verteilt. Dies sollte auf einer einzelnen GPU, einem Multi-GPU-Setup oder einer starken CPU funktionieren.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_path = "lfm2.5-2.6b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

Das Argument `torch_dtype` halbiert den Speicherverbrauch im Vergleich zu voller float32-Präzision bei vernachlässigbarem Qualitätsverlust.

6. Für schwächere Hardware quantisieren

Wenn Ihr Rechner weniger als 8 GB RAM ohne GPU hat, laden Sie das Modell im 4-Bit-Modus. Quantisierung ist der größte Einzelfaktor, der es ermöglicht, lokale Agenten auf alten Laptops und Edge-Boxen auszuführen.

from transformers import BitsAndBytesConfig

quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    model_path,
    quantization_config=quant_config,
)

Mit 4-Bit-Quantisierung wird LFM2.5-2.6B im Speicher sehr klein. Es gibt einen leichten Abfall in der Ausgabequalität, aber Sie gewinnen die Fähigkeit, den Agenten auf fast jedem tragbaren Computer auszuführen.

7. Alternative: Mit llama.cpp auf reiner CPU ausführen

Wenn Sie eine hochoptimierte C++-Laufzeit bevorzugen, die gut auf CPUs funktioniert und GGUF-Quantisierung unterstützt, ist `llama.cpp` eine ausgezeichnete Wahl. Klonen und bauen Sie es zuerst:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release

Konvertieren Sie als Nächstes die Hugging-Face-Gewichte in das GGUF-Format:

python3 tools/convert_hf_to_gguf.py ../lfm2.5-2.6b-instruct --outfile lfm2.5-2.6b-q8.gguf

Führen Sie schließlich eine rohe Inferenz aus, um die Installation zu überprüfen:

./build/bin/llama-cli -m lfm2.5-2.6b-q8.gguf -p "Explain local agents in one sentence." -n 128

Wenn Sie einen verständlichen Satz auf dem Terminal sehen, ist die Bereitstellung aktiv.

Anwendungsbeispiele

Das Modell zu installieren ist nur die halbe Miete. Der eigentliche Wert entsteht, wenn Sie es in eine Agentenschleife einbetten, die Tools verwenden kann. Im Folgenden gehen wir von einem einfachen Chat-Aufruf zu einem vollwertigen Agenten mit Tool-Aufrufen und einer HTTP-API über.

1. Einfache Textgenerierung

Beginnen Sie mit einer einfachen Generierung, um zu bestätigen, dass das Modell Ende-zu-Ende funktioniert. Wir verwenden die Chat-Vorlage des Modells, damit die Ausgabe der Konversationsformatierung folgt.

prompt = tokenizer.apply_chat_template(
    [{"role": "user", "content": "What is the fastest way to test an agent loop?"}],
    tokenize=False,
    add_generation_prompt=True,
)

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)
response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

Wenn dies funktioniert, ist das Modell bereit, ein Agent zu werden.

2. Eine Tool-Aufruf-Agentenschleife bauen

Die Kernidee eines Agenten ist eine Schleife: Das Modell erhält eine Aufgabe, entscheidet, welches Tool es aufrufen soll, das Tool wird ausgeführt, das Ergebnis wird zurückgespeist, und das Modell erzeugt die endgültige Antwort. Unten finden Sie eine minimale, aber vollständige Implementierung in reinem Python. Sie verwendet reguläre Ausdrücke, um eine JSON-Aktion zu extrahieren, was die Abhängigkeiten auf null reduziert.

import json
import re
from transformers import pipeline

generator = pipeline("text-generation", model=model, tokenizer=tokenizer)

# Example tools: replace with your own functions
TOOLS = {
    "get_weather": lambda city: f"The weather in {city} is 21°C and clear.",
    "get_git_status": lambda repo: "3 files changed, 42 insertions(+)",
}

def run_agent(prompt: str, max_steps: int = 5) -> str:
    messages = [
        {
            "role": "system",
            "content": (
                "You are a local agent. Choose a tool and respond with JSON "
                'in this format: {"tool": "name", "args": {...}}. '
                "Otherwise, reply in plain text."
            ),
        },
        {"role": "user", "content": prompt},
    ]

    for _ in range(max_steps):
        reply = generator(
            messages,
            max_new_tokens=120,
            do_sample=False,
        )[0]["generated_text"][-1]["content"]

        match = re.search(r'\{"tool": "(.*?)", "args": (\{.*?\})\}', reply, re.DOTALL)

        if not match:
            return reply

        tool_name, raw_args = match.group(1), match.group(2)
        args = json.loads(raw_args)

        result = TOOLS[tool_name](**args)

        messages.append({"role": "assistant", "content": reply})
        messages.append({"role": "tool", "content": result})

    return "Max steps reached without conclusion."

print(run_agent("What's the weather in Brussels?"))

Lassen Sie uns durchgehen, was hier passiert. Die System-Prompt-Anweisung weist das Modell an, JSON auszugeben, wenn es ein Tool aufrufen möchte. Die Schleife erkennt dieses JSON, führt die entsprechende Python-Funktion aus, hängt das Ergebnis als neue Nachricht an und lässt das Modell fortfahren. Wenn das Modell entscheidet, dass kein Tool benötigt wird, endet die Schleife und gibt die Klartext-Antwort zurück.

Dieses Muster ist bewusst leichtgewichtig. Es hängt nicht von LangChain oder einem anderen Agent-Framework ab, was bedeutet, dass es überall laufen kann – auch in einem Docker-Container auf einem Raspberry Pi. Wenn Sie ein strukturierteres Format benötigen, werfen Sie einen Blick auf die LFM2.5-Modellkarte für die genaue Funktionsaufruf-Syntax, auf der das Modell trainiert wurde; die allgemeine Schleife bleibt gleich.

3. Den Agenten als HTTP-API bereitstellen

Ein lokaler Agent ist viel nützlicher, wenn andere Prozesse ihn aufrufen können. Lassen Sie uns die Agentenschleife über einen kleinen FastAPI-Server bereitstellen, damit Skripte, Dashboards und sogar andere Rechner in Ihrem lokalen Netzwerk mit ihm kommunizieren können.

Installieren Sie zuerst die Server-Abhängigkeiten:

pip install fastapi uvicorn pydantic

Speichern Sie den folgenden Code als `server.py`:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class AgentRequest(BaseModel):
    prompt: str
    max_steps: int = 5

class AgentResponse(BaseModel):
    output: str

@app.post("/agent", response_model=AgentResponse)
def agent_endpoint(req: AgentRequest):
    return AgentResponse(output=run_agent(req.prompt, req.max_steps))

Starten Sie dann den Server:

uvicorn server:app --host 0.0.0.0 --port 8000

Das Flag `--host 0.0.0.0` macht die API für andere Geräte in Ihrem Netzwerk verfügbar, sodass Ihr Telefon, der Laptop eines Kollegen oder ein IoT-Modul alle Prompts an denselben lokalen Agenten senden können.

Testen Sie es mit `curl`:

curl -X POST http://localhost:8000/agent \
  -H "Content-Type: application/json" \
  -d '{"prompt": "What is the weather in Brussels?"}'

Skalierung auf produktionstaugliche lokale Bereitstellungen

Die obigen Beispiele decken die Einzelbenutzernutzung ab. Wenn Sie planen, LFM2.5-2.6B als Agentendienst für ein Team oder eine Flotte von Geräten bereitzustellen, sollten Sie in Betracht ziehen, von `transformers` zu einer produktionsreifen Inferenz-Engine wie `vLLM` zu wechseln, die kontinuierliches Batching und einen viel höheren Durchsatz bietet. Die Installation ist unkompliziert:

pip install vllm

Starten Sie dann einen OpenAI-kompatiblen Endpunkt:

vllm serve your-org/LFM2.5-2.6B-instruct --max-model-len 8192

Sobald es läuft, können Standard-OpenAI-Clientbibliotheken eine Verbindung herstellen, indem sie die Basis-URL auf `http://localhost:8000/v1` zeigen. Dadurch können Sie vorhandene Agent-Frameworks und Tools wiederverwenden, ohne Cloud-Guthaben zu verbrauchen.

Für Flottenbereitstellungen überall – einschließlich Edge-Geräten mit gemischter GPU/CPU-Hardware – behalten Sie einen einzigen gemeinsamen GGUF- oder 4-Bit-Checkpoint, übertragen Sie ihn über Ihr Standard-Konfigurationsmanagement-Tool auf jedes Gerät und führen Sie überall dieselbe Agentenschleife aus.

Fazit

Lokale Agenten sind kein Nischenhobby mehr. Die KI-Branche bewegt sich gleichzeitig in zwei komplementäre Richtungen: Frontier-Labore wie OpenAI, Microsoft und Anthropic treiben weiterhin Cloud-Maßstäbe voran, während die Open-Source-Community, die auf dem Hugging Face Blog ausführlich verfolgt wird, beweist, dass kleine Modelle eine überraschende Menge an realer Automatisierung bewältigen können. LFM2.5-2.6B passt genau in diese zweite Kategorie.

In diesem Artikel haben Sie den gesamten Lebenszyklus einer lokalen Agenten-Bereitstellung durchlaufen: Installation der Python-Umgebung, Herunterladen der Modellgewichte von Hugging Face, Laden mit voller Präzision oder quantisiert, Aufbau einer Tool-Aufruf-Schleife von Grund auf und Bereitstellung dieser Schleife über HTTP. Sie haben auch den Weg zu einer produktionsreifen Einrichtung mit `vLLM` oder einem reinen CPU-`llama.cpp`-Backend gesehen.

Die Erkenntnis ist einfach: Mit etwa 2,6 Milliarden Parametern und der richtigen Bereitstellungspipeline benötigen Sie kein Rechenzentrum, um einen Agenten auszuführen. Sie brauchen einen Laptop, ein paar Werkzeuge und die Bereitschaft zu experimentieren. Die Agenten, die Sie bauen, können Ihre Dateien lesen, das Web abfragen, das Wetter prüfen, Git-Repositorys verwalten oder Ihr Zuhause automatisieren – alles lokal, privat und ohne wiederkehrende Gebühren.

Das ist das Versprechen, lokale Agenten überall einzusetzen. Das Modell ist geladen. Die Tools sind verbunden. Was wird Ihr Agent tun?