building-inferencesh-apps

Übersicht

Was ist building-inferencesh-apps?

Das Skill building-inferencesh-apps ist ein fokussierter Leitfaden zum Erstellen und Deployen von Anwendungen auf der Plattform inference.sh. Er erklärt den Standard-Workflow für Apps, die Rolle des infsh CLI und wie du Backend-ähnliche Apps in Python oder Node.js sicher scaffoldest und verwaltest.

Dieses Skill ist kein generisches Tutorial, sondern auf die offiziellen infsh app-Kommandos und die Erwartungen der inference.sh Runtime abgestimmt. Es hilft dir, typische Fehler zu vermeiden – etwa das manuelle Anlegen zentraler Dateien, das falsche Konfigurieren von App-Ressourcen oder das Deployen aus dem falschen Verzeichnis.

Für wen ist dieses Skill gedacht?

Nutze building-inferencesh-apps, wenn du:

• Backend-Entwickler bist und API-artige Apps auf inference.sh betreiben möchtest
• Python- oder Node.js-Engineer bist und Modelle oder externe APIs als gehosteten Service kapseln willst
• Ein CLI-first-Developer bist, der einen vorhersagbaren, skriptbaren Deployment-Flow bevorzugt
• Die Plattform nutzt und einen Überblick über GPU/VRAM-Ressourcen, App-Secrets und Integrationen brauchst

Wenn du verstehen möchtest, wie eine inference.sh App strukturiert sein sollte, wie die Dateien inf.yml und inference.py / inference.js generiert werden und wie du sicher mit der Plattform arbeitest, ist dieses Skill ein guter Einstieg.

Welche Probleme löst es?

Das Skill building-inferencesh-apps adressiert häufige Stolpersteine beim Einstieg in die inference.sh App-Entwicklung:

• Unklarheit, wie eine neue App korrekt gescaffoldet wird
• Manuelles Anlegen von inf.yml, inference.py, inference.js oder package.json, das mit den Erwartungen der Plattform kollidiert
• Vergessen, vor infsh-Kommandos in das App-Verzeichnis zu cd
• Verlust von output_meta-Daten, weil von der falschen Basisklasse geerbt wird
• Fehlendes Logging, das das Debuggen von Remote-/API-lastigen Apps erschwert

Wenn du die in diesem Skill zusammengefassten Praktiken befolgst, erhältst du einen konsistenten, reproduzierbaren Workflow für das Erstellen und Deployen von inference.sh Apps.

Wann ist building-inferencesh-apps sinnvoll?

Dieses Skill passt besonders gut, wenn:

• Du eine neue App auf inference.sh startest und den kanonischen Workflow nutzen möchtest
• Du das infsh CLI bereits installiert hast oder installieren willst und alles über die Kommandozeile steuern möchtest
• Du Python- oder Node.js-Backends bauen möchtest, inklusive Wrappern um externe APIs oder Modelle

Weniger hilfreich ist es, wenn:

• inference.sh nicht dein Deployment-Ziel ist
• Du nur Client-seitigen Code oder Frontend-UI-Patterns benötigst
• Du eine Point-and-Click-GUI erwartest statt CLI-gesteuerter Workflows

Wenn dein Hauptziel stabiles, automatisiertes Backend- und API-Deployment auf inference.sh ist, passt building-inferencesh-apps sehr gut zu deinen Anforderungen.

Verwendung

1. inference.sh CLI installieren

Das Skill building-inferencesh-apps setzt voraus, dass du für alle App-Operationen das offizielle inference.sh CLI infsh verwendest.

CLI installieren

Führe das Installationsscript in deinem Terminal aus:

curl -fsSL https://cli.inference.sh | sh

Aktualisiere nach der Installation bei Bedarf auf die neueste Version:

infsh update

Halte das CLI aktuell, damit Scaffolding und Deployment deiner Apps den aktuellen Erwartungen der Plattform entsprechen.

2. Das Skill building-inferencesh-apps hinzufügen

Installiere dieses Skill in deiner Agent-Umgebung, damit es auf die kuratierten Regeln und Anleitungen zugreifen kann:

npx skills add https://github.com/inferen-sh/skills --skill building-apps

Damit verknüpfst du deinen Agent mit den Inhalten unter sdk/building-apps im Repository inferen-sh/skills und machst die App-Building-Regeln als wiederverwendbare Fähigkeit verfügbar.

3. Apps mit infsh app init scaffolden (niemals von Hand)

Die zentrale Regel in building-inferencesh-apps lautet: Alle Apps müssen über das CLI gescaffoldet werden. Die Plattform erwartet bestimmte Dateien und Strukturen, die das CLI für dich erzeugt.

Verbindliche Scaffolding-Regel

• Erstelle nicht manuell:
  • inf.yml
  • inference.py
  • inference.js
  • __init__.py
  • package.json
  • App-Verzeichnisse
• Ignoriere lokale Dokumente oder Strukturdateien, die manuelles Scaffolding empfehlen (z. B. PROVIDER_STRUCTURE.md).

Verwende stattdessen immer:

infsh app init

Das CLI erzeugt die korrekte Verzeichnisstruktur und die zentralen Dateien, die für eine gültige inference.sh App erforderlich sind – egal ob du Python oder Node.js als Ziel verwendest.

4. Aus dem richtigen App-Verzeichnis arbeiten

Das Skill building-inferencesh-apps betont, dass das aktuelle Shell-Verzeichnis für jedes infsh-Kommando entscheidend ist:

• Führe vor infsh-Kommandos wie init, deploy oder test immer ein cd in dein App-Verzeichnis aus.
• Das aktuelle Shell-Verzeichnis bleibt nicht zwischen separaten Tool-Aufrufen bestehen. Jede Automatisierung oder jeder Agent, der dieses Skill nutzt, muss daher bei jedem Aufruf das Verzeichnis explizit wechseln.

Typisches Muster:

cd path/to/your-app
infsh app deploy

Wenn du das cd überspringst, riskierst du, die falsche App zu deployen oder zu testen oder verwirrende Fehlermeldungen zu erhalten, weil inf.yml im aktuellen Verzeichnis nicht gefunden wird.

5. Outputs in Python-Apps korrekt definieren

Für Python-Apps, die Metadaten in ihren Outputs enthalten, hebt building-inferencesh-apps eine wichtige Regel hervor:

• Wenn deine Output-Klasse output_meta verwendet, muss sie von BaseAppOutput erben.
• Erbe nicht von BaseModel für solche Outputs.

Wenn du von BaseModel erbst, werden output_meta-Felder stillschweigend aus der Antwort entfernt. Durch die Verwendung von BaseAppOutput stellst du sicher, dass sowohl die Daten als auch die zugehörigen Metadaten von der Runtime korrekt übernommen und zurückgegeben werden.

6. Logging in run() für Observability hinzufügen

Das Skill empfiehlt, standardmäßig Logging in der run()-Methode deiner App zu integrieren:

• Nutze self.logger.info(...)-Aufrufe innerhalb von run(), um wichtige Events, Laufzeiten sowie Request-/Response-Zusammenfassungen zu protokollieren.
• Das ist besonders wichtig für API-wrappende Apps, bei denen die eigentliche Arbeit auf externen Services stattfindet und nicht in deinem eigenen Code.

Beispielhafte Anwendungsfälle für Logging:

• Messen der Latenz von Upstream-Model-Calls
• Protokollieren, welche externen API-Endpunkte aufgerufen wurden
• Nachverfolgen von Request-Größen oder Parametern, die für GPU/VRAM-Nutzung relevant sind

Konsistentes Logging macht es deutlich einfacher, Performance-Probleme zu debuggen und zu verstehen, wie sich dein inference.sh Backend im Produktivbetrieb verhält.

7. Typischer Entwicklungs- und Deployment-Flow

Auch wenn der Ausschnitt aus dem Repository vor allem Regeln enthält, kannst du building-inferencesh-apps als mentale Checkliste für einen typischen Workflow nutzen:

1. Installiere das infsh CLI.
2. Initialisiere eine neue App mit infsh app init (Python oder Node.js).
3. Wechsle in das Verzeichnis der neu angelegten App, bevor du weitere Kommandos ausführst.
4. Implementiere deine App-Logik in den generierten Dateien – unter Beachtung der BaseAppOutput-Regel für Outputs mit output_meta und mit Logging über self.logger.info(...).
5. Konfiguriere Ressourcen (z. B. GPU/VRAM und Integrationen) über die vom CLI generierte Konfiguration, nicht indem du inf.yml manuell anlegst.
6. Deploye und teste aus dem App-Verzeichnis heraus mit infsh-Kommandos.

Wann immer du diesen Flow erweiterst oder automatisierst, gelten dieselben Regeln: Verlasse dich beim Aufbau der Struktur auf das CLI, achte auf das korrekte Arbeitsverzeichnis und halte Output- und Logging-Patterns konsistent.

FAQ

Ist building-inferencesh-apps nur für Python?

Nein. Das Skill building-inferencesh-apps deckt Anwendungen auf inference.sh ab, die in Python oder Node.js geschrieben sein können. Dasselbe CLI (infsh app init) wird zum Scaffolding für beide Sprachen verwendet, und die Hinweise zu Verzeichnis-Handling und CLI-Nutzung gelten gleichermaßen.

Warum darf ich inf.yml oder inference.py nicht manuell erstellen?

Die inference.sh Plattform erwartet eine bestimmte Struktur, Felder und Beziehungen zwischen den Dateien. Wenn du inf.yml, inference.py, inference.js, package.json oder App-Verzeichnisse manuell anlegst, kann das zu subtilen Fehlkonfigurationen führen. Das Skill building-inferencesh-apps besteht auf infsh app init, weil das CLI ein gültiges, aktuelles Layout erzeugt, das den jeweils geltenden Anforderungen der Plattform entspricht.

Was passiert, wenn ich vergesse, ins App-Verzeichnis zu cden?

Wenn du infsh-Kommandos im falschen Verzeichnis ausführst, kann das CLI:

• Auf der falschen App operieren
• inf.yml oder zentrale App-Dateien nicht finden
• Verwirrende Fehlermeldungen ausgeben oder eine andere App deployen als beabsichtigt

Um das zu vermeiden, behandelt das Skill building-inferencesh-apps cd path/to/app als obligatorischen Schritt vor jedem infsh-Kommando – insbesondere in geskripteten oder Agent-gesteuerten Workflows.

Wie sollte ich Output-Klassen mit output_meta strukturieren?

Für Python-Apps gilt:

• Jede Output-Klasse, die output_meta enthält, muss von BaseAppOutput erben.
• Verwende für diese Outputs nicht BaseModel, da output_meta dann stillschweigend aus der Antwort entfernt wird.

Wenn du diese Regel befolgst, bleiben Metadaten erhalten und werden von inference.sh korrekt zurückgegeben.

Warum legt das Skill so viel Wert auf Logging in run()?

Building-inferencesh-apps hebt Logging hervor, weil viele inference.sh Apps API-Wrapper sind oder stark von externen Services abhängen. Ohne Logging über self.logger.info(...) innerhalb von run() ist es schwierig:

• Latenz- und Performance-Probleme zu analysieren
• Fehler in Upstream-APIs zu verstehen
• Requests und Responses beim Debuggen sauber zu korrelieren

Schon einfache Logs auf Info-Level verschaffen dir Transparenz darüber, was dein Backend bei jedem Request tatsächlich macht.

Erklärt das Skill GPU- und VRAM-Settings im Detail?

Das Skill ist auf den Workflow und die Regeln für die inference.sh App-Entwicklung ausgerichtet: Scaffolding über das CLI, Umgang mit Verzeichnissen, Anforderungen an Output-Klassen und Logging. Es soll dir beim Nachdenken über App-Ressourcen wie GPU und VRAM, Secrets und Integrationen helfen, aber der Repository-Ausschnitt konzentriert sich eher auf Regeln als auf ausführliche Konfigurationsbeispiele. Für eine präzise Ressourcenkonfiguration solltest du dieses Workflow-Skill mit der offiziellen inference.sh Dokumentation kombinieren.

Wann sollte ich building-inferencesh-apps nicht verwenden?

Dieses Skill ist weniger geeignet, wenn:

• Du nicht auf inference.sh deployst
• Du Frontend- oder UI-Frameworks suchst statt Anleitung für Backend-Apps
• Du Files und Verzeichnisse lieber manuell anlegst statt CLI-gesteuerter Workflows

In allen anderen Fällen – insbesondere beim Aufbau von API-orientierten Backends auf inference.sh – bietet dir building-inferencesh-apps ein verlässliches, CLI-zentriertes Muster, dem du folgen kannst.