Llama Stack: Ein Leitfaden mit praktischen Beispielen

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:

1. 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.
2. 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:

• Arbeiten mit Lama 3 Kurs
• Llama 3.2 feinjustieren und lokal nutzen
• RAG mit Llama 3.1 8B, Ollama und Langchain