Schnellstart

1. Installieren

curl -fsSL https://greppy.xyz/install.sh | sh

Im Terminal öffnet der Installer ein kleines Menü. Wählst du die Installation, zeigt er zuerst die Coding-Agents, die er einrichten kann, die gefundenen schon angehakt, und fragt, welche davon greppy nutzen sollen (siehe Schritt 3). Dann prüft er deine Plattform (macOS auf Apple Silicon oder Linux x86_64; unter Linux warnt er, wenn der NVIDIA-Treiber fehlt), lädt das Release von GitHub, prüft seinen SHA-256, entpackt es unter ~/.local/share/greppy/versions/ und verlinkt ~/.local/bin/greppy dorthin. sudo brauchst du dafür nicht.

Optionen hängst du nach sh -s -- an, zum Beispiel für eine bestimmte Version:

curl -fsSL https://greppy.xyz/install.sh | sh -s -- --version v0.3.2

Jede Option, die genauen Dateien, die der Installer anfasst, und die drei Stufen der Deinstallation stehen in der Installer-Referenz.

Lieber von Hand? Lade das Paket für deine Plattform (.pkg für macOS, .deb oder .rpm für Linux) und SHA256SUMS von der Release-Seite, prüfe es mit shasum -a 256 --ignore-missing -c SHA256SUMS und installiere es mit dem Paketmanager deiner Plattform (installer -pkg, dpkg -i, rpm -U). Installiere das Binary als greppy, nie als grep. Signatur und Herkunft prüfst du wie unter Sicherheit und Verifikation beschrieben.

Aus dem Quellcode bauen

Zum Bauen brauchst du Rust ≥ 1.95, eine C-Toolchain, jq und curl. fetch_model_assets.sh lädt vier Modelldateien mit zusammen 814 MB:

git clone https://github.com/metric-space-ai/greppy && cd greppy
git checkout v0.4.1
./tools/fetch_model_assets.sh
cargo build --locked --release --bin greppy
install -m 0755 target/release/greppy "$HOME/.local/bin/greppy"

Der Build schaltet das GPU-Backend deiner Plattform automatisch ein: Metal auf Apple Silicon, CUDA auf Linux x86_64 (mit nvcc). cargo build bricht ab, wenn eine Modelldatei fehlt oder ihr SHA-256 nicht stimmt. fetch_model_assets.sh ist idempotent: Es prüft vorhandene Dateien und lädt neu, sobald eine Prüfsumme abweicht.

2. Die erste Abfrage

Ein beliebiges Repository reicht. Die Ausgaben hier stammen aus serde 1.0.229:

git clone --branch v1.0.229 https://github.com/serde-rs/serde && cd serde
greppy --version
greppy index .                       # Graph und Embeddings für dieses Repository bauen
greppy doctor --root . --json        # Index und Inferenz-Backend Ende-zu-Ende prüfen
greppy who-calls visit_content_map   # deine erste Graph-Abfrage

greppy index meldet sofort auf stderr die erste Phase, seine PID und den Status-Befehl, zum Beispiel (phase=preparing_base, pid=3293); progress: `greppy index status --json`. Am Ende folgt je eine Zusammenfassung für den Graphen und für die Embeddings. greppy doctor --root . --json liefert den vollständigen Gesundheitsbericht (für serde 443 Zeilen JSON) und endet mit 0, wenn Index und Backend bereit sind.

$ greppy --version
greppy 0.4.1
$ greppy index .
…
indexed 219 files (120 unsupported, 0 unreadable, 0 oversize, 0 file-limit, 0 time-budget); 4571 nodes extracted; generation 1 (project: serde)
embedded 2443 code spans (0 local-store reused, 2443 global-cache hits, 0 inference misses, 4573 considered, 2150 non-definition skipped, 0 missing-file, 0 invalid-span, 0 oversize, 0 failed, 0 stale pruned)
$ greppy who-calls visit_content_map
serde/src/private/de.rs:1152  ContentDeserializer::deserialize_any
serde/src/private/de.rs:1399  ContentDeserializer::deserialize_map
serde/src/private/de.rs:1415  ContentDeserializer::deserialize_struct

Die zweite Zeile von greppy index zeigt, woher die Embeddings kommen: aus dem Store dieses Repositorys (local-store reused), aus dem nutzerweiten Cache (global-cache hits) oder frisch berechnet (inference misses). serde war auf diesem Rechner schon einmal eingebettet, darum kamen alle 2443 aus dem Cache. Der Graph wird einmal pro Repository gebaut und über Sitzungen hinweg wiederverwendet.

greppy index darfst du auch weglassen: Eine erste Graph-Abfrage wie who-calls baut den Graphen selbst und antwortet, sobald er veröffentlicht ist. Die Embeddings für die semantische Suche übernimmt die erste search: Sie baut die fehlenden Embeddings und antwortet, sobald sie vollständig sind, ohne Teiltreffer.

Seit 0.4.1 meldet eine erste Graph-Abfrage, die auf den Build warten muss, ihre Phasen auf stderr, zum Beispiel who-calls — writing_graph: 154/219 files; phase ETA about 40s. Kann die Indexierung nicht starten, endet die Abfrage mit dem temporären Code 75 und nennt die Bedingung für den nächsten Versuch.

Bereitschaft in Skripten prüfen

Skripte, die semantische Suche brauchen, rufen greppy index . auf und prüfen dann:

greppy index status --json | jq '{status, healthy, embedding_complete, fresh}'

{
  "status": "ok",
  "healthy": true,
  "embedding_complete": true,
  "fresh": true
}

Starte semantische Arbeit, sobald der Befehl mit 0 endet und "healthy": true und "embedding_complete": true meldet. Der Befehl blockiert nie, der Exit-Code sagt dir, was zu tun ist:

3. Agent anbinden

Das erledigt der Installer. Er speichert den Prompt, der zu deiner installierten Version gehört, als ~/.greppy/AGENTS.md und trägt ihn in die globalen Anweisungen jedes Coding-Agents ein, den du anhakst:

Jeder Eintrag steht zwischen den Markern <!-- greppy:begin … --> und <!-- greppy:end -->. Die Originaldatei bleibt als *.greppy-backup erhalten, und ein zweiter Installer-Lauf ersetzt den Block, statt einen weiteren anzuhängen. Welche Agents greppy nutzen, änderst du später mit dem Installer über Set up coding agents only; --uninstall entfernt jeden Block.

Für jeden anderen Agent kopierst du ~/.greppy/AGENTS.md als AGENTS.md in dein Projektverzeichnis. Das ist die ganze Integration: kein MCP-Server, keine Konfiguration pro Agent, keine API-Keys. Der Graph baut sich bei der ersten Abfrage. Agent einrichten erklärt, was der Prompt deinem Agent sagt.

Nächste Schritte

• Im Graphen navigieren und Suchen beschreiben die Befehle, die dein Agent am häufigsten nutzt.
• Transaktional editieren zeigt, wie du Code auf denselben Belegen änderst.
• Builds und Tests ausführen hält Build-Logs aus dem Kontext deines Agents heraus.
• Klappt etwas nicht, führe greppy doctor --json aus und hänge die Ausgabe (private Pfade geschwärzt) an ein GitHub-Issue, zusammen mit greppy --version, Betriebssystem, CPU, GPU und Treiberversion.