Lokales KI-Modell Needle 2: Tool-Calling in der Praxis mit 14 MB

Das Pebble Index Ring hat keinen Bildschirm. Wenn jemand zu dem Ring spricht, muss die Aktion passieren, mit oder ohne Internet. Genau dafür setzt Pebble ein kleines Sprachmodell direkt in der App ein. Gründer Eric Migicovsky beschreibt es so: „Wir führen Cactus Needle lokal in der App aus, statt uns auf die Cloud zu verlassen. Der Fußabdruck des Modells ist winzig, und die Leistung enttäuscht uns nie." 2

Titelbild: Bildquelle: cactus-compute/needle

Dieses Modell heißt Needle 2: ein offenes Modell mit 45 Millionen Parametern für drei Aufgaben: Tool-Calling, Gerätesteuerung und strukturierte Extraktion. Es steckt als ein einziges 14-MB-Binary auf der Platte und läuft eine Sitzung in rund 28 MB Arbeitsspeicher 1, steht unter der Apache-2.0-Lizenz, der Quellcode liegt auf GitHub, die Gewichte auf Hugging Face 1, 2.

Die Zahl 14 MB bezeichnet die Dateigröße des komprimierten Binaries, nicht die Parameterzahl: 45 Millionen Parameter werden über eine 2-Bit-Quantisierung („Cactus Quants", CQ2) auf diese 14 MB gepresst 1, 2.

In diesem Artikel zeige ich dir Schritt für Schritt, wie du Needle 2 lokal installierst, eigene Werkzeuge deklarierst und strukturierte Daten extrahierst, plus eine Entscheidungshilfe: wann sich dieses kleine Modell lohnt und wann ein größeres besser passt. Alle Zahlen stammen aus der offiziellen Dokumentation oder unabhängigen Einordnungen und sind am Ende verlinkt.

Kurzantwort

Needle 2 ist ein 45-Mio.-Parameter-Modell für Tool-Calling in einem 14-MB-Binary. So installierst du es, definierst Werkzeuge und prüfst die Grenzen. Kurz gesagt: ki tools praxis ist vor allem dann relevant, wenn du schnell verstehen willst, was konkret dahinter steckt, welche Grenzen es gibt und welche Entscheidung daraus folgt. Die Details, Quellen und Einschränkungen stehen in den folgenden Abschnitten.

Was Needle 2 ist — und was es bewusst nicht ist

Needle 2 löst jedes Problem als Funktionsaufruf. Du deklarierst, welche Werkzeuge zur Verfügung stehen, und das Modell antwortet mit Aufrufen, nicht mit Freitext. Eine Anfrage, die kein deklariertes Werkzeug bedienen kann, wird mit dem leeren Aufruf [] abgelehnt; es gibt keinen Freitext-Fallback 3. Diese Designentscheidung erklärt fast alles andere an dem Projekt.

Die offizielle Begründung lautet so: Ein Licht einzuschalten braucht kein großes Modell. Smartwatches, Sprachassistenten und Roboter stellen ihre Fähigkeiten ohnehin als Funktionen mit typisierten Parametern bereit; die einzige schwierige Aufgabe ist, einen unordentlichen Satz darauf abzubilden. Dafür braucht es weder Weltwissen noch offene Absätze, deshalb reichen 45 Millionen Parameter, wo Chat-Modelle Milliarden brauchen 2.

Technisch baut Needle 2 auf dem auf, was das Team „Simple Attention Network" nennt: eine Hadamard-MLP ersetzt das übliche Feed-Forward-Netz, dazu GQA-Attention, ein Engram-Speicher aus gehashten n-Gramm-Tabellen und mehrspurige Hyper-Verbindungen 1. Das zugrunde liegende Paper ist auf arXiv als „A Controlled Study of Attention-Only Transformers" veröffentlicht 6. Das Netz ist laut offizieller Seite 27 Schichten tief und 512 breit, vortrainiert auf 115 Milliarden Token (proprietär) und nachtrainiert auf 38 Milliarden 2, 7.

Wichtig für die Einordnung: Needle 2 ist kein Chatbot. Das 256-Token-Kontextfenster ist bewusst kurz ausgelegt für einzelne Tool-Calling-Entscheidungen, nicht für offene Konversation 1, 8; lange Zusammenfassungen, Smalltalk oder komplexes Schlussfolgern sind nicht sein Einsatzgebiet 8.

Installation und erster Test

Die Installation ist ein einziger Befehl. Das Paket heißt cactus-needle und kommt von PyPI:

pip install cactus-needle

Die Inferenz-Engine wird beim ersten Start einmalig von Hugging Face geladen und lokal zwischengespeichert; danach läuft alles ohne Netzwerk 1. Wer zusätzlich Fine-Tuning oder Checkpoint-Export will, installiert das Trainings-Extra:

pip install "cactus-needle[train]"

Für einen schnellen Test ohne eigenen Code gibt es ein Playground im Browser; der Server initialisiert das Modell vor dem ersten Aufruf:

needle playground                      # Basismodell, http://127.0.0.1:7860
needle playground --weights my.cact    # ein feingetuntes Modell

Das minimale Python-Beispiel aus dem README deklariert eine Funktion, markiert sie als Werkzeug und lässt das Modell den Aufruf entscheiden 1:

import needle

@needle.tool
def get_weather(city: str):
    "Get the current weather for a city."
    return {"city": city, "temp_c": 27, "sky": "clear"}

agent = needle.Needle(tools=[get_weather])
print(agent.run("what's it like in Lagos right now?")["results"])
# [{'city': 'Lagos', 'temp_c': 27, 'sky': 'clear'}]

Der Kern liegt in der Beschreibung der Werkzeuge. Needle liest die Signatur für die Argumenttypen und den Docstring als Werkzeugbeschreibung. run() führt die Schleife komplett aus: Das Modell wählt den Aufruf, Needle führt deine Funktion aus, füttert das Ergebnis zurück und liefert am Ende die Antwort mit den ausgeführten Ergebnissen als results 1.

Bildquelle: cactus-compute/needle

Eigene Werkzeuge deklarieren

Die Qualität hängt fast vollständig davon ab, wie gut du deine Werkzeuge beschreibst. Needle liest einen Google-Stil-Args:-Block für Parameterbeschreibungen. Ein Default macht ein Argument optional; ein Literal wird zur festen Menge, aus der das Modell wählen muss und aus der es nichts anderes ausgeben kann 3:

from typing import Literal

@needle.tool
def set_thermostat(temperature: int, mode: Literal["heat", "cool", "auto"] = "auto"):
    """Set the thermostat.

    Args:
        temperature: target temperature in Celsius
        mode: heating strategy to use
    """
    return {"temperature": temperature, "mode": mode}

Werte lassen sich mit needle.Field über Annotated einschränken. Bereiche, Muster, Längen und Elementanzahlen werden in die Dekodier-Grammatik kompiliert, das Modell kann also nur Werte ausgeben, die diese Regeln erfüllen 3:

from typing import Annotated

@needle.tool
def send_money(
    amount: Annotated[float, needle.Field(gt=0, le=10000, description="USD, up to 10,000")],
    to:     Annotated[str,   needle.Field(pattern=r"^@[a-z0-9_]+$", description="recipient handle")],
    memo:   Annotated[str,   needle.Field(max_length=80)] = "",
):
    "Send money to a handle."
    return {"sent": amount, "to": to}

Wer den Dekorator nicht mag, übergibt das JSON-Schema direkt. Der Dekorator baut intern nur genau dieses Schema, Needle konsumiert es ohnehin 3:

tools = [{
    "name": "set_lights",
    "description": "Turn a room's lights on or off and set brightness",
    "parameters": {
        "type": "object",
        "properties": {
            "room": {"type": "string", "description": "which room to control"},
            "on": {"type": "boolean"},
            "brightness": {"type": "integer", "minimum": 0, "maximum": 100},
        },
        "required": ["room", "on"],
    },
}]
agent = needle.Needle(tools=tools)

Eine Analogie für den Mechanismus: Die Grammatik funktioniert wie eine Schablone. Bevor das Modell ein Token erzeugt, weiß die Engine, welche Zeichen an dieser Stelle erlaubt sind. So kann kein syntaktisch falsches JSON entstehen, und die Engine spart auf Struktur-Token bis zu 98 Prozent der Vokabular-Projektion ein 2, 3.

Bis zu fünf Werkzeuge werden direkt eingebettet. Darüber greift ein Retrieval-Kopf ein: Jedes Schema wird einmal eingebettet, pro Zug wird die Anfrage gescored, nur die fünf besten landen im Kontext; ein nicht ausgewähltes Werkzeug ist damit nicht nur unwahrscheinlich, sondern unerreichbar 1, 3.

Strukturierte Daten extrahieren

Extraktion ist in Needle kein eigener Modus, sondern Tool-Calling mit genau einem Werkzeug: Du deklarierst den Datensatz als Schema und übergibst den Text dort, wo sonst die Anfrage steht. Mit einem deklarierten Werkzeug erlaubt die Grammatik genau einen Aufruf dieses Namens, Konformität ist garantiert statt nur erbeten 3. Über den extract()-Helfer mit einem Pydantic-Modell bekommst du ein typisiertes Objekt zurück 1:

from pydantic import BaseModel

class Invoice(BaseModel):
    vendor: str
    total: float
    due_date: str

invoice = needle.extract("Invoice from Acme Corp, $1,200.00, due 2026-09-01", Invoice)
print(invoice.vendor, invoice.total)   # -> Acme Corp 1200.0

Wer die Schleife selbst steuern will, nutzt complete() statt run(). Jede Runde liefert genau ein JSON-Objekt zurück; bei "call" führst du den Aufruf aus und gibst das Ergebnis als nächste complete()-Runde zurück 3:

import json
response = agent.complete("dim the living room to 30")
if response["type"] == "call":
    (call,) = response["function_calls"]
    result = set_lights(**call["arguments"])
    response = agent.complete(json.dumps(result))

Ein Detail aus der Dokumentation, das für die Praxis wichtig ist: Argumente enthalten nur Werte, die in der Eingabe belegt sind. Ein optionales Feld ohne Beleg wird weggelassen, nicht geraten 3. Das Modell erfindet also keinen Wert für ein Feld, das der Nutzer nicht genannt hat.

Wer nicht bei null anfangen will, findet unter needle.environments sechs fertige Werkzeugoberflächen: smart_home, media_player, productivity, wearable, kitchen_appliance und data_capture. Jede bringt höchstens fünf kuratierte Werkzeuge mit, deren Enums und Grenzen sauber auf Needles eingeschränkte Dekodierung abgestimmt sind, dazu einen fertigen Agenten und eine eingefrorene Testsuite mit 32 Fällen 4. python -m needle.environments.smart_home führt die Suite von der Shell aus; run_tests() gilt bei mindestens 90 Prozent bestandenen Fällen und ohne kritischen Fehler als bestanden 4.

Confidence-Gating: wann das Modell „Nein" sagt

Jede Antwort trägt einen confidence-Wert. Er ist das Minimum aus zwei Signalen: einem kalibrierten Kopf, der den kompletten Prompt samt erzeugtem Aufruf bewertet, und der Dekodier-Wahrscheinlichkeit der Aufruf-Token. Ein Aufruf wird nur akzeptiert, wenn beide übereinstimmen. Die Folge: Der Fehlermodus ist Eskalation, nicht falsche Ausführung 3.

Der offizielle Vertrag: Wähle einen Schwellenwert, handle bei oder über dem Wert, frag nach oder leite an ein größeres Modell weiter, wenn du darunter liegst 2, 3. Off-Topic-Anfragen liefern den leeren Aufruf [] 3. Das ist ein Sicherheitsmerkmal, kein Defekt: Ein kleines Modell, das „das kann ich nicht" sagt, ist oft brauchbarer als eines, das rät.

Zwei dokumentierte Einschränkungen. Erstens gilt die Kalibrierung nur für das Basismodell: Fine-Tuning aktualisiert den Kopf nicht, ein Agent mit getunten Gewichten meldet confidence als None und warnt einmal 3, 5. Zweitens Vorsicht bei nicht-englischen Eingaben: Die Doku misst korrekte spanische Aufrufe mit Confidence 0,0 und rät, den Score außerhalb von Englisch zurückhaltend zu behandeln 5.

Über den optionalen System-Turn übergibst du Umgebungszustand als Fakten, nie als Anweisung. Erkannte Schlüssel sind date, locale, device, battery, network, location, user und assistant; nur mit einem date:-Fakt wird aus „tomorrow at 7" eine absolute Zeit, sonst bleibt der Ausdruck wörtlich 3.

Offline und auf kleinen Geräten

Der Hauptgrund, Needle 2 in Betracht zu ziehen, ist nicht die Modellqualität, sondern der Betrieb ohne Cloud und mit sehr wenig Ressourcen. Die Inferenz selbst berührt nie das Netzwerk, ein Air-Gap-Gerät braucht nur die eine gecachte Engine-Datei 1, 3. Der Cache liegt unter ~/.cache/cactus-needle/<engine version>/. Drei Wege dorthin sind dokumentiert 3:

1. needle fetch lädt die Engine für die aktuelle Maschine in den Cache. Mit --platform-tag holst du den Build für ein anderes Gerät.
2. Die Datei auf demselben Cache-Pfad ablegen oder in das installierte needle/-Paketverzeichnis kopieren.
3. NEEDLE_LIB_PATH=/pfad/zu/libneedle.so setzen, um genau diese Datei zu laden und jede Suche zu überspringen.

Für Geräte ohne jede Netzanbindung: pip download cactus-needle auf einer verbundenen Maschine, dann pip install --no-index --find-links <dir> auf dem Gerät, plus HF_HUB_OFFLINE=1, damit eine fehlende Engine mit klarem Fehler abbricht statt herunterzuladen 3.

Die Plattformabdeckung ist breiter, als ein 14-MB-Binary vermuten lässt. Laut unabhängiger Einordnung liefert Cactus vorgebaute Binaries und eine statische Bibliothek für macOS, Linux (x86-64, ARM64, ARMv7, RISC-V, MIPS32el), Windows, Android, iOS/watchOS/tvOS und WebAssembly 7. Auf der offiziellen Seite nennt das Team zusätzlich Mikrocontroller-Klasse: Mit der 28-MB-RAM-Obergrenze passe Needle auf Teile mit externem RAM wie ESP32-S3, ESP32-P4 mit 32 MB PSRAM oder STM32H7- und NXP-i.MX-RT-Boards mit SDRAM, und die Engine kompiliere single-threaded für Bare-Metal und liefere eine statische Bibliothek für Cortex-M4, M7 und M55 2.

Die angegebenen Geschwindigkeiten, jeweils von der offiziellen Seite 2: rund 500 Token pro Sekunde Decode auf einem Raspberry Pi 5, 400 bis 1.500 auf VR-Headsets wie Meta Quest 3S und Apple Vision Pro, 300 bis 700 auf Handys unter 200 US-Dollar. Das sind Herstellerangaben, keine unabhängig gemessenen Werte.

Zur Transparenz: Cactus sammelt strikt anonyme Telemetrie (Funktionsname, Paketversion, Betriebssystem, niemals Prompts oder Daten). Abstellen kannst du sie mit NEEDLE_TELEMETRY=0 oder DO_NOT_TRACK=1 1.

Benchmarks: Was die Zahlen zeigen

Needle 2 wird auf fünf öffentlichen Funktions-Calling-Benchmarks mit „ordered strict exact match" bewertet: Eine Zeile zählt nur, wenn Funktionsnamen, Aufrufreihenfolge und jeder Argumentwert exakt stimmen 2, 7. Die Ergebnisse, auf der offiziellen Seite veröffentlicht und von MarkTechPost unabhängig wiedergegeben 2, 7:

• Mobile Actions (961 Zeilen): Needle 2 erreicht 63,7 Prozent, LFM2.5-230M 69,1, FunctionGemma-270M 64,0, Apple FM 57,6. Bei der Funktionnamens-Genauigkeit liegt Needle 2 mit 98,3 Prozent vorn.
• DroidCall (200 Zeilen): 17,0 gegen 17,5 (FunctionGemma) und 11,0 (LFM2.5).
• Seal-Tools in-domain (700) und out-of-domain (654 Zeilen): 32,6 und 28,7 für Needle 2, gegen LFM2.5 (26,9 / 17,0) und FunctionGemma (16,3 / 15,6).
• BFCL v4 single-turn (3.641 Zeilen): 42,6 gegen 60,8 (LFM2.5), 46,1 (FunctionGemma) und 61,7 (Apple FM), bei einer Well-formed-Rate von 93,4 Prozent.

Das Muster deckt sich mit der Positionierung: Needle 2 liegt in den Geräte-Aktions-Benchmarks (Seal-Tools) vorn und fällt in BFCL zurück, das allgemeine und Enterprise-APIs außerhalb seiner Trainingsverteilung abdeckt; die Lücke liegt laut Team in Java, JavaScript und parallelen Mehrfach-Aufrufen 2. Beide Asymmetrien werden offen ausgewiesen: Die Baselines laufen in f16, was sie begünstigt; die Spezialisierung begünstigt Needle 2, 7.

Die Effizienzseite ist der eigentliche Punkt des Projekts. Laut offizieller Seite verbringt Needle 2 70 MFLOPs pro Token, gegenüber 460 bei LFM2.5-230M, 540 bei FunctionGemma-270M und rund 6.000 bei Apple FM; das sind 7- bis 85-mal weniger pro Token als die Modelle, gegen die es antritt 2. Diese Zahlen sind wiederum Herstellerangaben.

Fine-Tuning: wann es sich lohnt

Fine-Tuning ist bei Needle 2 der offiziell empfohlene Weg. Der Grund liegt in der engen Spezialisierung: Dein Produkt stellt eine feste, begrenzte Menge an Werkzeugen bereit, ein darauf trainiertes kleines Spezialmodell schlägt laut offizieller Seite ein großes Allzweckmodell. Die Seite nennt 21 bis 58 Prozentpunkte Zuwachs, mit dem Needle 2 auf drei von vier Benchmarks vor DeepSeek V4 Flash landet 2.

Technisch läuft das über LoRA-Adapter auf der eingefrorenen Basis, die beim Export wieder in die Gewichte gemerged werden; das Ergebnis ist wieder ein einzelnes .cact-Archiv 5. Das Datenformat ist JSONL, ein Beispiel pro Zeile:

{"query": "dim the kitchen to 10", "tools": [{"name": "set_lights", "parameters": {"type": "object", "properties": {"room": {"type": "string"}, "brightness": {"type": "integer"}}, "required": ["room"]}}], "answers": [{"name": "set_lights", "arguments": {"room": "kitchen", "brightness": 10}}], "reasoning": "'kitchen' -> room; 'dim to 10' -> brightness 10"}

Die dokumentierten Regeln, die beim Datensatz wirklich zählen 5: Argumente enthalten nur Werte, die in der Anfrage vorkommen; optionale Felder ohne Beleg weglassen, niemals mit Platzhaltern füllen; Off-Topic-Beispiele mit "answers": [] einstreuen (der eingebaute Generator erzeugt etwa eines von acht), sonst ruft das getunte Modell auf alles ein Werkzeug auf; bei ähnlichen Werkzeugen mehrdeutige Anfragen aufnehmen, die zum richtigen aufgelöst werden.

Die Befehle sind knapp 1, 5:

needle finetune data.jsonl --epochs 10
needle build checkpoints/needle2.pkl --lora checkpoints/needle_lora.pkl --out tuned.cact

Für synthetische Daten gibt es needle generate-data, das einen OPENROUTER_API_KEY braucht. Training ist pures JAX und läuft auf jeder von JAX unterstützten Beschleunigung: auf NVIDIA mit pip install "cactus-needle[train,gpu]", auf Apple Silicon mit [train,metal] 1, 5.

Zwei Stolpersteine aus der Doku sparen Zeit. Erstens die Verlustkurve: Der Loss startet nahe 1,0 statt nahe Zufall, weil ein Großteil des Aufrufs Boilerplate ist, den das Basismodell schon kann; bewerte den Trend, nicht das Niveau. Zweitens die Schrittanzahl: 200 Beispiele bei Batch 16 sind 13 Schritte pro Epoche, drei Epochen also 39, was einen Rank-16-Adapter kaum bewegt; bei wenigen hundert Beispielen rät die Doku zu 10 bis 30 Epochen 5. Werkzeugauswahl lernt das Modell schon mit wenigen hundert sauberen Beispielen, die korrekte Argument-Zuordnung erst mit Tausenden 5.

FAQ

Ist Needle 2 kostenlos und kommerziell nutzbar?

Ja. Das Projekt steht unter der Apache-2.0-Lizenz, kommerzielle Nutzung ist erlaubt, solange die Lizenzbedingungen eingehalten werden 1, 8.

Auf welcher Hardware läuft es?

Bestätigte Herstellerangaben nennen praktische Geschwindigkeiten auf Raspberry Pi 5 und auf Handys unter 200 US-Dollar, bei rund 28 MB RAM pro Sitzung. Statische Bibliotheken für Cortex-M-Mikrocontroller erweitern das auf stark eingeschränkte Hardware 2, 8.

Brauche ich eine GPU?

Für Inferenz nicht. Für Fine-Tuning optional: JAX läuft auch auf der CPU, GPU-Training über [train,gpu] (NVIDIA) oder [train,metal] (Apple Silicon) 1, 5.

Wie definiere ich eigene Werkzeuge?

Mit dem @needle.tool-Dekorator, wobei Signatur und Docstring das Schema liefern, oder direkt als JSON-Schema. Literal erzwingt geschlossene Mengen, needle.Field Wertegrenzen 3.

Was bedeutet der Confidence-Wert?

Er ist das Minimum aus einem kalibrierten Kopf und der Dekodier-Wahrscheinlichkeit des Aufrufs. Du setzt einen Schwellenwert und handelst darüber, darunter eskalierst du oder fragst nach 2, 3.

Wie betreibe ich es komplett offline?

Die Engine wird einmal gecacht, Inferenz geht nie ins Netz. needle fetch lädt sie vorab, NEEDLE_LIB_PATH bindet eine bestimmte Datei, HF_HUB_OFFLINE=1 verhindert Netzversuche 1, 3.

Kann ich es in eine eigene App einbetten?

Grundsätzlich ja, über das dependency-freie C++-Binary beziehungsweise die statische Bibliothek. Dedizierte SDKs für Flutter, React Native, Kotlin und Swift sind auf der offiziellen Seite nicht dokumentiert 8.

Wann sollte ich stattdessen ein größeres Modell nehmen?

Für lange Zusammenfassungen, Smalltalk oder komplexes Schlussfolgern. Das 256-Token-Fenster und die 45 Millionen Parameter sind auf schmale, wiederkehrende Entscheidungen ausgelegt, nicht auf allgemeine Konversation 8.

Wie viel Daten brauche ich fürs Fine-Tuning?

Wenige hundert saubere Beispiele für die Werkzeugauswahl, Tausende für korrekte Argument-Zuordnung, jeweils mit Reasoning-Zeilen und variierten Formulierungen 5.

Fazit

Needle 2 beantwortet eine präzise Frage: Wie bringe ich Tool-Calling und strukturierte Extraktion auf Geräte ohne GPU, mit wenig RAM und ohne Netz. Dafür ist es ein ernstzunehmendes Werkzeug: 14 MB, Apache-2.0, dokumentierte Offline-Pfade und eine klare Eskalationslogik über den Confidence-Wert.

Die Gegenprobe ist genauso klar. Wer allgemeine Konversation, lange Kontexte oder breite API-Abdeckung braucht, ist hier falsch; die BFCL-Zahlen zeigen das unmissverständlich. Zwei Dinge solltest du vor einer Entscheidung selbst testen: die Confidence-Kalibrierung in deiner Sprache, die außerhalb von Englisch laut Doku einbrechen kann, und die Fine-Tuning-Schwelle, ab der deine Werkzeuge die nötige Genauigkeit erreichen.

Der nächste Schritt ist konkret: installieren, ein Werkzeug deklarieren und die extract()-Runde nachvollziehen. Von dort entscheidet dein eigener Test, ob 45 Millionen Parameter reichen, nicht eine Sternzahl auf GitHub.

Passende Produktrecherchen

Wenn du die praktische Seite vertiefen möchtest, findest du hier passende Suchpfade zum Vergleichen. Keine Kaufpflicht, keine Rangliste, sondern thematisch passende Produktrecherchen:

• USB-C-Sticks für lokale Smartphone-Backups recherchieren
• GL.iNet Router für Testnetze und Reise-VPNs ansehen
• Managed Switches für Netzwerksegmentierung recherchieren
• Datenschutzfreundliche Android-Phones vergleichen
• LiFePO4-Speicher für Balkonkraftwerke ansehen

Hinweis: Als Amazon-Partner verdient kalika.de an qualifizierten Verkäufen. Für dich ändert sich der Preis nicht.

Bildquelle: cactus-compute/needle

Weiterführende Artikel

• KI-Tools Praxis: Prime Agent installieren, nutzen und absichern
• OpenLogi: Native Alternative zu Logitech Options+ ohne Konto und Telemetrie
• Muse Glimmer 30B: Metas lokales Agentenmodell in der Praxis – Einrichtung, Benchmarks, Grenzen
• KI-Tools selbst hosten in der Praxis: Private Websuche und lokale Sprachmodelle auf dem Mini-PC
• Übersetzen ohne Cloud: KI-Modell lokal im Browser betreiben

Grenzen der Einordnung

Die zitierten Daten beschreiben eine Erhebung beziehungsweise einen allgemeinen Markt- oder Regelungsstand. Sie ersetzen weder eine technische Prüfung noch eine individuelle Kostenrechnung. Änderungen bei Preisen, Förderung, Netzentgelten oder Vorgaben können das Ergebnis beeinflussen; daher sollten Leserinnen und Leser die Primärquellen vor einer konkreten Entscheidung erneut prüfen.

Transparenzhinweis

Dieser Beitrag wurde mit Unterstützung künstlicher Intelligenz erstellt und automatisiert auf Quellen, Fakten und Qualitätskriterien geprüft.

Quellen

[1] cactus-compute/needle – README

[2] Cactus Compute – Needle 2 (offizielle Produktseite)

[3] doc/apis.md – API, Confidence, Offline

[4] doc/environments.md – vorgefertigte Werkzeugoberflächen

[5] doc/finetuning.md – LoRA, Datenformat, Loss

[6] arXiv:2607.18363 – A Controlled Study of Attention-Only Transformers

[7] MarkTechPost – Meet Needle 2 (unabhängige Einordnung)

[8] Oflight – Needle 2: Cactus Compute’s 14MB On-Device Agent LLM