Course
Llama Stack: Ein Leitfaden mit praktischen Beispielen
Obwohl generative KI Anwendungen massiv an Zugkraft gewonnen haben, ist die Herausforderung, effiziente und konsistente Anwendungen zu entwickeln und sie einzusetzen, noch nicht gelöst.
Llama Stack, ein Open-Source-Projekt von Meta, geht auf diese Komplexität ein.
Llama Stack führt ein standardisiertes Framework und modulare APIs ein, die eine schnellere und reibungslosere Entwicklungserfahrung bieten. Es definiert und standardisiert die Bausteine, die benötigt werden, um generative KI-Anwendungen auf den Markt zu bringen.
In diesem Artikel führe ich dich mit einer Schritt-für-Schritt-Anleitung durch die ersten Schritte mit Llama Stack. Wenn du ein Entwickler bist, der eine KI-Anwendung in der Produktion einsetzen will, solltest du unbedingt das Llama Stack Repositoryda es ständig weiterentwickelt wird.
KI-Anwendungen entwickeln
Lerne, wie man KI-Anwendungen mit der OpenAI API erstellt.
Was ist Llama Stack?
Llama Stack ist ein Framework, das die Entwicklung und den Einsatz von generativen KI-Anwendungen auf der Grundlage von Meta's Llama Modelle. Dies wird durch die Bereitstellung einer Sammlung standardisierter APIs und Komponenten für Aufgaben wie Inferenz, Sicherheit, Speicherverwaltung und Agentenfähigkeiten erreicht.
Hier sind seine Ziele und Vorteile:
- Normung: Die APIs bieten Entwicklern eine einheitliche Schnittstelle und Arbeitsumgebung, mit der sie ihre Anwendungen schnell anpassen können, sobald neue Modelle verfügbar sind.
- Synergie: Durch die Abstrahierung komplexer Funktionen in APIs wird die Zusammenarbeit zwischen verschiedenen Tools und Komponenten ermöglicht, was der Modularität und Flexibilität zugute kommt.
- Reibungslose Entwicklung: Llama Stack bietet Mautgebühren für einen vereinfachten Entwicklungslebenszyklus, indem es Kernfunktionen vordefiniert und die Bereitstellung beschleunigt.
Quelle: Meta AI
Llama Stack Komponenten und APIs
Llama Stack wird mit mehreren APIs geliefert, die jeweils auf bestimmte Aufgaben beim Aufbau einer generativen KI-Anwendung abzielen.
Inferenz-API
Die Inference API übernimmt die Erzeugung von Text oder Eingabeaufforderungen multimodale Llama-Variationen. Seine wichtigsten Merkmale sind:
- Es unterstützt verschiedene Dekodierungsstrategien wie das Top-K-Sampling.
- Sie verwaltet Batch-Anfragen und Stream-Antworten, was für umfangreiche Anwendungen nützlich ist.
Die API definiert verschiedene Konfigurationen, mit denen Entwickler das Modellverhalten steuern können (z. B. FP8 oder BF16 Quantisierung) je nach den Anforderungen ihrer Anwendung steuern können.
Sicherheit API
Die Safety API wurde entwickelt für verantwortungsvollen Einsatz von KI-Modellen durch die Moderation von Inhalten und das Filtern von schädlichen oder potenziell verzerrten Ergebnissen. Sie kann so konfiguriert werden, dass sie Verletzungsstufen (z.B. INFO, WARN, ERROR) festlegt und Meldungen an die Benutzer/innen zurückgibt.
Speicher-API
Die Memory API ermöglicht es, vergangene Interaktionen zu speichern und auf sie zurückzugreifen, um kohärentere und kontextbewusste Konversationen zu führen. Die verschiedenen Speicherkonfigurationen geben Entwicklern die Möglichkeit, je nach Anwendungsbedarf verschiedene Speichertypen zu wählen. Seine wichtigsten Merkmale sind:
- Es ermöglicht eine flexible Speichermöglichkeit, indem es verschiedene Konfigurationen wie Vektor, Key-Value, Keyword und Graph bietet, die im Wesentlichen Methoden zur Speicherung von Konversationsspeichern sind.
- Ermöglicht das Einfügen, Abfragen, Aktualisieren und Löschen von Dokumenten in Speicherbänken. Die Abfrageergebnisse werden als Chunks mit Relevanzbewertungen zurückgegeben.
Agentische API
Die Agenten-API ermöglicht es LLMs, externe Tools und Funktionen zu nutzen, mit denen sie Aufgaben wie Websuche, Codeausführung oder Speicherabruf durchführen können. Die API ermöglicht Entwicklern die Konfiguration von Agenten mit bestimmten Tools und Zielen zu konfigurieren. Es unterstützt Multi-Turn-Interaktionen, bei denen jeder Zug aus mehreren Schritten besteht. Seine wichtigsten Merkmale sind:
- Es kommt mit integrierten Tools wie brave_search, wolfram_alpha, photogen und code_interpreter. Wir können diese Werkzeuge nutzen, um Anfragen zu bearbeiten oder Code im Kontext des Modells auszuführen.
- Sie arbeitet mit der Memory API zusammen, um relevante Informationen abzurufen und den langfristigen Kontext zu verbessern.
- Modelle können Aufgaben in mehreren Schritten ausführen, z. B. Inferenz, Werkzeugausführung, Speicherabruf und Sicherheitsprüfungen.
Andere APIs
Hier sind die anderen APIs, die Llama Stack anbietet:
- Bewertung API: Verwendet zur Bewertung der Modellleistung.
- Nach der Ausbildung API: Hilft bei der Feinabstimmung von Modellen für bestimmte Aufgaben oder Daten, mit Methoden wie LORA, DORA, etc.
- Synthetische Datenerzeugung API: Hilft bei der Erstellung synthetischen Datensätzen für Trainingsmodelle.
- Belohnungsbewertung API: Nützlich für Verstärkungslernen Szenarien, um Aktionen oder Entscheidungen des Modells mit Belohnungspunkten zu versehen.
So installierst und richtest du Llama Stack ein
Wir werden ein Beispielprojekt auf Llama Stack implementieren, um uns mit der allgemeinen Idee und den Möglichkeiten dieses Frameworks vertraut zu machen.
Bevor wir beginnen, solltest du wissen, dass:
- Llama Stack entwickelt sich schnell weiter und es ist zu erwarten, dass du bei der Implementierung deines Clients auf Fehler stößt. Zum Zeitpunkt des Schreibens dieses Artikels konnte ich den Llama Stack-Container zum Beispiel nicht unter Windows ausführen, weil es einige betriebssystemspezifische Probleme gab, an denen das Entwicklerteam arbeitet.
- Du kannst Llama Stack nicht auf Google Colab verwenden, da die kostenlose Version der Plattform keine Docker-Container bauen kann.
Beginnen wir mit der Einrichtung der Llama-Befehlszeilenschnittstelle (CLI).
1. Llama CLI
Der Llama Stack bietet eine Befehlszeilenschnittstelle (CLI) für die Verwaltung von Distributionen, die Installation von Modellen und die Konfiguration von Umgebungen. Hier sind die Installationsschritte, die wir durchführen müssen:
1. Erstelle und aktiviere eine virtuelle Umgebung:
conda create -n llama_stack python=3.10
conda activate llama_stack
2. Klone das Llama Stack Repository:```bash
git clone <https://github.com/meta-llama/llama-stack.git>
cd llama-stack
3. Install the required dependencies:```bash
pip install -r requirements.txt
2. Docker Container verwenden
Docker Container vereinfachen die Bereitstellung des Llama Stack Servers und der Agenten-API-Anbieter. Vorgefertigte Docker-Images sind für eine einfache Einrichtung verfügbar:
docker pull llamastack/llamastack-local-gpu
llama stack build
llama stack configure llamastack-local-gpu
Diese Befehle ziehen das Docker-Image, bauen es und konfigurieren den Stack.
Wie man eine App mit Llama Stack APIs erstellt
Lass uns einen einfachen Chatbot mit den Llama Stack APIs bauen. Hier sind die Schritte, die wir unternehmen müssen:
1. Starte den Llama Stack Server
Wir werden den Server auf Port 5000 laufen lassen. Stelle sicher, dass der Server läuft, bevor du mit den APIs arbeitest:
llama stack run local-gpu --port 5000
2. Verwende die Inference API
Nachdem du den Llama Stack installiert hast, kannst du Client-Code verwenden, um mit seinen APIs zu interagieren. Verwende die Inferenz-API, um Antworten auf der Grundlage von Benutzereingaben zu generieren:
from llama_stack_client import LlamaStackClient
client = LlamaStackClient(base_url="<http://localhost:5000>")
user_input = "Hello! How are you?"
response = client.inference.chat_completion(
model="Llama3.1-8B-Instruct",
messages=[{"role": "user", "content": user_input}],
stream=False
)
print("Bot:", response.text)
Hinweis: Ersetze "Llama3.1-8B-Instruct"
durch den tatsächlichen Modellnamen, der in deiner Einrichtung verfügbar ist.
3. Integriere die Sicherheits-API
Implementiere die Sicherheits-API, um Antworten zu moderieren und sicherzustellen, dass sie angemessen sind:
safety_response = client.safety.run_shield(
messages=[{"role": "assistant", "content": response.text}],
shield_type="llama_guard",
params={}
)
if safety_response.violation:
print("Unsafe content detected.")
else:
print("Bot:", response.text)
4. Speicher mit der Speicher-API hinzufügen
Schaffe das Kontextbewusstsein des Chatbots, indem du den Gesprächsverlauf speicherst und abrufst:
### building a memory bank that can be used to store and retrieve context.
bank = client.memory.create_memory_bank(
name="chat_memory",
config=VectorMemoryBankConfig(
type="vector",
embedding_model="all-MiniLM-L6-v2",
chunk_size_in_tokens=512,
overlap_size_in_tokens=64,
)
)
5. Komponenten miteinander verketten
Wir können die APIs weiter kombinieren, um einen robusten Chatbot zu bauen:
- Inference API: Erzeugt Antworten.
- Sicherheit API: Filtert unangemessene Inhalte.
- Speicher-API: Behält den Gesprächskontext bei.
Vollständiges Beispiel
Hier ist der vollständige Code, nachdem du alle Schritte durchgeführt hast:
import uuid
client = LlamaStackClient(base_url="<http://localhost:5000>")
### create a memory bank at the start
bank = client.memory.create_memory_bank(
name="chat_memory",
config=VectorMemoryBankConfig(
type="vector",
embedding_model="all-MiniLM-L6-v2",
chunk_size_in_tokens=512,
overlap_size_in_tokens=64,
)
)
def get_bot_response(user_input):
### retrieving conversation history
query_response = client.memory.query_documents(
bank_id=bank.bank_id,
query=[user_input],
params={"max_chunks": 10}
)
history = [chunk.content for chunk in query_response.chunks]
### preparing messages with history
messages = [{"role": "user", "content": user_input}]
if history:
messages.insert(0, {"role": "system", "content": "\\n".join(history)})
### generate response
response = client.inference.chat_completion(
model="llama-2-7b-chat",
messages=messages,
stream=False
)
bot_response = response.text
### safety check
safety_response = client.safety.run_shield(
messages=[{"role": "assistant", "content": bot_response}],
shield_type="llama_guard",
params={}
)
if safety_response.violation:
return "I'm sorry, but I can't assist with that request."
### memory storing
documents = [
MemoryBankDocument(
document_id=str(uuid.uuid4()),
content=user_input,
mime_type="text/plain"
),
MemoryBankDocument(
document_id=str(uuid.uuid4()),
content=bot_response,
mime_type="text/plain"
)
]
client.memory.insert_documents(
bank_id=bank.bank_id,
documents=documents
)
return bot_response
### putting all together
while True:
user_input = input("You: ")
if user_input.lower() == "bye":
break
bot_response = get_bot_response(user_input)
print("Bot:", bot_response)
Llama Stack Beispiele und Beiträge
Um einige Beispiele zu sehen und mit der Implementierung von Anwendungen mit Llama Stack zu beginnen, hat Meta die llama-stack-apps Repository zur Verfügung gestellt, in dem du dir einige Beispielanwendungen anschauen kannst. Mach dich unbedingt mit dem Rahmenwerk vertraut.
Als Open-Source-Projekt lebt Llama Stack von den Beiträgen der Community. Die APIs entwickeln sich schnell weiter, und das Projekt ist offen für Feedback und die Beteiligung von Entwicklern, um die Zukunft der Plattform mitzugestalten. Wenn du Llama Stack testest, kann es anderen Entwicklern helfen, wenn du dein Projekt auch als Beispiel teilst oder zur Dokumentation beiträgst.
Fazit
In diesem Artikel haben wir Schritt für Schritt erklärt, wie du mit Llama Stack loslegen kannst.
Wenn du mit dem Einsatz deiner KI-Anwendungen vorankommst, behalte das Llama Stack Repository für die neuesten Updates und Erweiterungen im Auge zu behalten.
Wenn du mehr über das Ökosystem der Lamas erfahren willst, schau dir die folgenden Ressourcen an:
Masterstudent der Künstlichen Intelligenz und technischer Redakteur für KI. Ich gebe Einblicke in die neuesten KI-Technologien, mache ML-Forschung zugänglich und vereinfache komplexe KI-Themen, die du brauchst, um ganz vorne mit dabei zu sein.
Lerne KI mit diesen Kursen!
Course
MLOps Deployment and Life Cycling
Course
Developing LLM Applications with LangChain
Der Blog