Llama 3.3 70B Function Calling: Nahtlose Integration für bessere Leistung

Wichtigste Highlights

Was es tut: Ausführung von Echtzeit-Datenabrufen, Systemoperationen und automatisierten Workflows.

Welche Modelle es unterstützen: Llama 3-Serie, GPT-Serie, Gemma 2 und Mistral Nemo.

Wie man es implementiert: Installieren Sie APIs über die Novita AI-“Modellbibliothek” und implementieren Sie es dann mit dem Langchain-Framework.

Function Calling ist eine Technik, die die Fähigkeiten großer Sprachmodelle (LLMs) erheblich verbessert, indem sie ihnen ermöglicht, mit der Außenwelt zu interagieren. Anstatt nur Text zu generieren, können LLMs Function Calling nutzen, um spezifische Aufgaben auszuführen, auf Echtzeitinformationen zuzugreifen und komplexe Operationen durchzuführen. Dieser Artikel untersucht das Konzept von Function Calling, seine praktischen Anwendungen und wie Modelle wie Llama 3.3 70B es zugänglicher machen.

Welche Probleme kann Function Calling lösen?

1. Zugriff auf Echtzeitinformationen

• Aktuelle Aktienkurse abrufen
• Aktuelle Wetterdaten abrufen
• Auf aktuelle Nachrichten zugreifen

2. Systeminteraktionen

• E-Mails senden
• In sozialen Medien posten
• Datenbanken abfragen und beschreiben

3. Workflow-Automation

• Datenscraping und -verarbeitung
• Ausführung mehrstufiger Aufgaben
• Automatisierung komplexer Analysen

4. Datenrichtigkeit

• Sicherstellung der Aktualität von Informationen
• Bereitstellung präziser Abfrageergebnisse
• Reduzierung von Fehlern durch veraltete Daten

Was ist Function Calling?

Im Kern ist Function Calling die Fähigkeit eines LLM, zu erkennen, wann eine bestimmte Aufgabe eine externe Funktion oder ein externes Werkzeug erfordert, und dann strukturierte Daten (typischerweise im JSON-Format) auszugeben, um die Funktion auszuführen. Diese strukturierten Daten enthalten den Namen der Funktion und alle erforderlichen Argumente. Im Wesentlichen fungiert Function Calling als Brücke zwischen dem umfangreichen Wissen der KI und konkreten Aktionen. Es befähigt KI-Agenten oder Chatbots, bestimmte Aufgaben auszuführen oder auf externe Daten und Dienste zuzugreifen.

Unterstützte Modelle für Function Calling

Viele LLMs und Plattformen unterstützen jetzt Function Calling. Sie können die API über die Seite “Modellbibliothek” von Novita AI installieren und Function Calling über Langchain implementieren.

• Llama 3.3: Die Version mit 70 Milliarden Parametern hat in Function-Calling-Tests eine starke Leistung gezeigt, indem sie erfolgreich erkennt, wann und welche Funktionen basierend auf Benutzeranfragen aufgerufen werden sollen.
  • Llama 3.3 70B
  • Llama 3.1 70B
  • Llama 3.1 8B
• Mistral: Modelle wie Mistral-Large-2 zeigen Erfolg bei Function Calling in Umgebungen wie watsonx.ai.
  • Mistral Nemo
• Gemini: Die Gemini-Modelle von Google unterstützen ebenfalls Function Calling, mit verschiedenen verfügbaren Anwendungsbeispielen.
  • Gemma 2 9B

Wie funktioniert Function Calling?

1. Funktionsdeklaration: Der Prozess beginnt mit der Definition wiederverwendbarer Codeblöcke, den sogenannten Funktionen, zusammen mit Beschreibungen ihrer Fähigkeiten, Eingaben und Ausgaben.
2. Prompt-Einreichung: Der Benutzer reicht einen Prompt zusammen mit einer Reihe von Funktionsdeklarationen beim LLM ein. Dies informiert das Modell über die verfügbaren Werkzeuge.
3. Modellanalyse: Das LLM analysiert den Prompt und entscheidet, ob es eine der bereitgestellten Funktionen aufrufen muss, um die Anfrage zu erfüllen.
4. Strukturierte Ausgabe: Falls ein Funktionsaufruf erforderlich ist, generiert das LLM eine strukturierte Ausgabe im JSON-Format, die den Namen der Funktion und Werte für ihre Parameter enthält.
5. Funktionsaufruf: Die Anwendung oder das System verwendet diese strukturierte Ausgabe, um die angegebene Funktion aufzurufen und die Parameter zu übergeben.
6. Funktionsausführung: Der externe Dienst oder die API führt die Funktion mit den bereitgestellten Parametern aus.
7. Ausgabeantwort: Der externe Dienst sendet eine Bestätigung oder ein Ergebnis zurück an die KI.
8. Modellantwort: Das LLM verwendet diese Ausgabe dann, um eine natürliche Sprachantwort für den Benutzer oder zur weiteren Verarbeitung zu generieren.

• Beachten Sie, dass das Modell die Funktion nicht direkt aufruft; vielmehr wird seine strukturierte Ausgabe von einem externen Programm verwendet, um dies zu tun.

https://www.youtube.com/watch?v=Qor2VZoBib0

Function Calling vs. JSON-Modus

Vorteile von Function Calling

• Erhöhte Effizienz: Direktes Aufrufen von Funktionen führt zu schnelleren Verarbeitungszeiten und geringerer Latenz, was für Anwendungen, die sofortige Aktionen erfordern, entscheidend ist.
• Erhöhte Flexibilität: Entwickler können Funktionen einfach aktualisieren oder ändern, ohne ganze Anwendungen überarbeiten zu müssen, was schnellere Anpassungen an neue Anforderungen ermöglicht.
• Skalierbarkeit: Erleichtert die Skalierbarkeit, indem neue Funktionen hinzugefügt werden können, ohne dass umfangreiche Änderungen an der bestehenden Infrastruktur erforderlich sind.
• Personalisierte Interaktionen: Ermöglicht personalisierte Benutzererfahrungen; zum Beispiel durch Zugriff auf den Kalender eines Benutzers, um Meeting-Zeiten vorzuschlagen, die nicht mit bestehenden Terminen kollidieren.
• Brücke zwischen KI und realen Aktionen: Ermöglicht es der KI, praktische Aufgaben wie das Senden von E-Mails oder Textnachrichten im Namen von Benutzern auszuführen.
• Komplexe Konversationsagenten: Kann anspruchsvolle Chatbots erstellen, die komplexe Fragen mithilfe externer APIs und Wissensdatenbanken für relevante Antworten beantworten.

Praktische Anwendungen von Function Calling

• Konversationsagenten: Einsatz in fortschrittlichen Chatbots, die externe APIs für aktuelle Informationen nutzen.
• Natürlichsprachliche Verarbeitung: Extrahiert strukturierte Daten aus Text für Aufgaben wie Entitätserkennung und Stimmungsanalyse.
• API-Integration: Ermöglicht LLMs die Integration mit externen APIs zum Abrufen von Daten oder zur Ausführung von Aktionen basierend auf Benutzereingaben.
• Finanzassistenz: Erstellt KI-Finanzberater, die auf Echtzeit-Finanzdaten zugreifen und personalisierte Ratschläge geben.
• Automatisierung von Support-Tickets: Automatisiert die Zuweisung von Support-Tickets, indem Tickets mithilfe kontextbezogener Regeln verarbeitet werden.
• Wissensabruf: Hilft beim Abrufen von Informationen aus Wissensdatenbanken durch Erstellen von Funktionen, die akademische Artikel zusammenfassen, um Fragen zu beantworten und Zitate bereitzustellen.
• Multimodale Anwendungen: Startet Funktionen basierend auf Bildern, Videos, Audio und PDFs.

Wie man Llama 3.3 70B Function Calling über Novita AI verwendet

Schritt 1: API-Schlüssel abrufen und installieren!

Rufen Sie die Seite “Schlüsselverwaltung” auf und kopieren Sie den API-Schlüssel wie im Bild gezeigt.

Sie finden die Seite “Modellbibliothek” von Novita AI. Installieren Sie die Novita AI-API mit dem für Ihre Programmiersprache spezifischen Paketmanager.

Bei der Registrierung bietet Novita AI ein Guthaben von 0,50 $, um Ihnen den Einstieg zu erleichtern!

Wenn das kostenlose Guthaben aufgebraucht ist, können Sie bezahlen, um es weiter zu nutzen.

Schritt 2: Function Calling mit Langchain implementieren

Wir erstellen eine einfache Mathematik-Anwendung, die Additions- und Multiplikationsoperationen durchführen kann.

💡 Während diese Anleitung LangChain aus Gründen der Bequemlichkeit verwendet, erfordert die Implementierung von Function Calling kein spezifisches Framework. Der Schlüssel liegt im Entwerfen der richtigen Prompts, damit das Modell Funktionen versteht und korrekt aufruft. LangChain wird hier lediglich verwendet, um die Implementierung zu vereinfachen.

Voraussetzungen

Installieren Sie zunächst die erforderlichen Pakete:

pip install langchain-openai python-dotenv

Einrichten der Umgebung

Erstellen Sie eine .env-Datei im Stammverzeichnis Ihres Projekts und fügen Sie Ihren Novita AI API-Schlüssel hinzu:

NOVITA_API_KEY=your_api_key_here

Implementierungsschritte

1. Werkzeuge definieren

Erstellen wir zunächst zwei einfache mathematische Werkzeuge mit dem @tool-Dekorator von LangChain:

from langchain_core.tools import tool

@tool
def multiply(x: float, y: float) -> float:
    """Multiply two numbers together."""
    return x * y

@tool
def add(x: int, y: int) -> int:
    """Add two numbers."""
    return x + y

tools = [multiply, add]

2. Werkzeugausführungsfunktion erstellen

Implementieren Sie als Nächstes eine Funktion, um die Werkzeuge auszuführen:

from typing import Any, Dict, Optional, TypedDict
from langchain_core.runnables import RunnableConfig

class ToolCallRequest(TypedDict):
    name: str
    arguments: Dict[str, Any]

def invoke_tool(
    tool_call_request: ToolCallRequest, 
    config: Optional[RunnableConfig] = None
):
    """Execute the specified tool with given arguments."""
    tool_name_to_tool = {tool.name: tool for tool in tools}
    name = tool_call_request["name"]
    requested_tool = tool_name_to_tool[name]
    return requested_tool.invoke(tool_call_request["arguments"], config=config)

3. LangChain-Pipeline einrichten

Erstellen Sie eine Chain, die Novita AIs LLM verwendet, um Werkzeugaufrufe auszuwählen und vorzubereiten:

from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import render_text_description

def create_chain():
    """Create a chain that uses the specified LLM model to select and prepare tool calls."""
    model = ChatOpenAI(
        model="meta-llama/llama-3.3-70b-instruct",
        api_key=os.getenv("NOVITA_API_KEY"),
        base_url="https://api.novita.ai/v3/openai",
    )
    
    rendered_tools = render_text_description(tools)
    system_prompt = f"""\
    You are an assistant that has access to the following set of tools. 
    Here are the names and descriptions for each tool:

    {rendered_tools}

    Given the user input, return the name and input of the tool to use. 
    Return your response as a JSON blob with 'name' and 'arguments' keys.

    The `arguments` should be a dictionary, with keys corresponding 
    to the argument names and the values corresponding to the requested values.
    """

    prompt = ChatPromptTemplate.from_messages(
        [("system", system_prompt), ("user", "{input}")]
    )

    return prompt | model | JsonOutputParser()

4. Hauptverarbeitungsfunktion erstellen

Implementieren Sie die Hauptfunktion, die mathematische Abfragen verarbeitet:

def process_math_query(query: str):
    """Process a mathematical query by using an LLM to select the appropriate tool and execute it."""
    chain = create_chain()
    message = chain.invoke({"input": query})
    result = invoke_tool(message, config=None)
    return message, result

5. Anwendungsbeispiel

Hier sehen Sie, wie Sie die Implementierung verwenden:

if __name__ == "__main__":
    message, result = process_math_query(
        "meta-llama/llama-3.3-70b-instruct", 
        "what's 3 plus 1132"
    )
    print(result)  # Output: 1135

Zusammenfassend lässt sich sagen, dass Function Calling die Art und Weise, wie KI-Systeme mit ihrer Umgebung interagieren, rasant verändert und praktischere, effizientere und benutzerfreundlichere Anwendungen ermöglicht. Modelle wie Llama 3.3 70B ebnen den Weg für einen einfacheren Zugang zu dieser leistungsstarken Technologie und eröffnen zahlreiche Möglichkeiten für die KI-Entwicklung.

Häufig gestellte Fragen (FAQ)

Was ist Function Calling im Kontext von LLMs?

Function Calling ist eine Technik, die es großen Sprachmodellen ermöglicht, zu erkennen, wann eine bestimmte Aufgabe eine externe Funktion oder ein externes Werkzeug erfordert, und strukturierte Daten zu generieren, um diese Funktion auszuführen.

Was sind die Hauptvorteile der Verwendung von Function Calling?

Zu den Hauptvorteilen gehören eine höhere Effizienz bei der Aufgabenverarbeitung, mehr Flexibilität für Entwickler, um Funktionen einfach zu aktualisieren, Skalierbarkeit für das Hinzufügen neuer Funktionalitäten ohne umfangreiche Änderungen sowie personalisierte Benutzerinteraktionen.

Welche Sprachen unterstützt Llama 3.3?

Englisch, Französisch, Deutsch, Hindi, Italienisch, Portugiesisch, Spanisch und Thailändisch

Novita AI ist eine KI-Cloud-Plattform, die Entwicklern eine einfache Möglichkeit bietet, KI-Modelle über unsere einfache API bereitzustellen, und gleichzeitig eine erschwingliche und zuverlässige GPU-Cloud zum Aufbau und zur Skalierung bereitstellt.

Empfohlene Lektüre

• How to Access Llama 3.3 70b Locally or via API: A Complete Guide
• Revealing the Secrets of Llama 3.3 Multilingual Model
• Llama 3.3 70B: Features, Access Guide & Model Comparison