Wichtige Highlights
Novita AI hat Llama 4 Maverick vorgestellt! Außerdem unterstützt diese Version vollständig Function Calling.
Llama 4 Maverick kombiniert eine hochmoderne 128-Mixture-of-Experts (MoE)-Architektur mit fortschrittlichen multimodalen Fähigkeiten.
Wenn Sie seine Leistung testen möchten, starten Sie direkt eine kostenlose Testversion auf Novita AI Playground!
Llama 4 Maverick definiert KI mit überlegenen Function-Calling-Fähigkeiten neu und bietet unübertroffene Leistung, Echtzeit-Interaktion und globale Funktionalität durch seine fortschrittliche Architektur.
Was ist Function Calling?
Function Calling bezeichnet die Fähigkeit eines Systems, wie eines Modells oder einer Anwendung, während seiner Ausführung externe Funktionen oder Dienste aufzurufen. Diese Funktionen können APIs, Datenbanken oder andere Dienste sein, die spezifische Aufgaben außerhalb des Hauptmodells oder -systems ausführen.
- Externe Dienste: Die Funktion kann mit APIs, Datenbanken oder Drittanbieterdiensten interagieren (z. B. Zahlungsabwickler, Wetterdaten usw.).
- Echtzeit-Interaktion: Der Funktionsaufruf erfolgt während der Ausführung und liefert Live-Daten oder Aktionen.
- Vordefinierte Funktionen: Diese Funktionen sind in der Regel vordefiniert, d. h. das System weiß, was sie tun werden (z. B. Daten abrufen, Transaktionen verarbeiten).
https://www.youtube.com/watch?v=aqdWSYWC\_LI
Wie funktioniert Function Calling?
- Das System sendet eine Anfrage an eine externe Funktion (z. B. API oder Dienst).
- Die Funktion führt die Aufgabe aus (z. B. Daten abrufen, Informationen verarbeiten).
- Das Ergebnis wird an das System zurückgegeben, das es für die weitere Verarbeitung nutzt.
Welche Vorteile bietet Function Calling?
- Echtzeitdaten: Liefert aktuelle Informationen durch Interaktion mit externen Quellen.
- Erweiterte Funktionalität: Ermöglicht dem System die Nutzung externer Dienste (z. B. Zahlungsabwicklung, Wetterdaten).
- Modularität: Macht Systeme flexibler und anpassungsfähiger, indem externe Fähigkeiten integriert werden, ohne das Rad neu zu erfinden.
Function Calling vs. RAG
Function Calling Beispiel:
import requests
def get_weather(city: str):
# Replace with your actual API key and URL
api_key = "your_api_key"
url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
response = requests.get(url)
data = response.json()
if response.status_code == 200:
temperature = data['main']['temp']
description = data['weather'][0]['description']
return f"The current temperature in {city} is {temperature}°C with {description}."
else:
return "Sorry, I couldn't fetch the weather data at the moment."
# Use the function to get weather info for New York
city = "New York"
weather_info = get_weather(city)
print(weather_info)
RAG Beispiel:
from transformers import pipeline
# Simulated knowledge base (this could be a database or a larger dataset in a real application)
knowledge_base = {
"force majeure": "Force Majeure refers to unforeseeable circumstances that prevent someone from fulfilling a contract.",
"breach of contract": "A breach of contract occurs when one party fails to perform its obligations as outlined in the contract.",
"arbitration": "Arbitration is a method of resolving disputes outside the courts, where an arbitrator makes a binding decision."
}
def retrieve_information(query: str):
# Retrieve relevant information based on the query (could be replaced with a database query or more advanced search)
query = query.lower()
if query in knowledge_base:
return knowledge_base[query]
else:
return "Sorry, I couldn't find any relevant information in the knowledge base."
def generate_answer(query: str):
# Retrieve information first
retrieved_info = retrieve_information(query)
# Use a text generation model (e.g., GPT-2) for generating a response based on the retrieved information
model = pipeline("text-generation", model="gpt-2")
answer = model(f"Based on the information: {retrieved_info}. Answer the following question: {query}")[0]['generated_text']
return answer
# User query
query = "What is force majeure in a contract?"
answer = generate_answer(query)
print(answer)
Was ist Llama 4 Maverick?
| Kategorie | Element | Details |
|---|---|---|
| Basisinformationen | Veröffentlichungsdatum | 5. April 2025 |
| Modellgröße | 400B Parameter (17B aktiv/Token) | |
| Open Source | Open Source | |
| Architektur | 128 Mixture-of-Experts (MoE) | |
| Sprachunterstützung | Sprachunterstützung | Vorab trainiert auf 200 Sprachen. Unterstützt Arabisch, Englisch, Französisch, Deutsch, Hindi, Indonesisch, Italienisch, Portugiesisch, Spanisch, Tagalog, Thailändisch und Vietnamesisch. |
| Multimodal | Multimodale Fähigkeit | Eingabe: mehrsprachiger Text und Bild; Ausgabe: mehrsprachiger Text und Code |
| Training | Trainingsdaten | ~22 Billionen Token multimodaler Daten (einige von Instagram und Facebook) |
| Vorab-Training | MetaP: Adaptive Expertenkonfiguration + Mid-Training | |
| Post-Training | SFT (Einfache Daten) → RL (Schwierige Daten) → DPO |
So verwenden Sie Llama 4 Maverick Function Calling über Novita AI
Novita AI hat Unterstützungsbeschreibungen für jedes LLM veröffentlicht, die Sie direkt in der [Konsole](https://novita.ai/models-console/?utm_source=blog_llm&utm_medium=article&utm_campaign=/ llama-4-maverick-function-calling/) und in der [Dokumentation](https://novita.ai/docs/guides/llm-function-calling/?utm_source=blog_llm&utm_medium=article&utm_campaign= llama-4-maverick-function-calling) einsehen können.
1. Client initialisieren
Zuerst müssen Sie den Client mit Ihrem Novita-API-Schlüssel initialisieren.
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Get the Novita AI API Key from: https://novita.ai/settings/key-management.
api_key="<YOUR Novita AI API Key>",
)
model = "meta-llama/llama-4-maverick-17b-128e-instruct-fp8"
- Die aufzurufende Funktion definieren
Als nächstes definieren Sie die Python-Funktion, die das Modell aufrufen kann. In diesem Beispiel ist es eine Funktion zum Abrufen von Wetterinformationen.
# Example function to simulate fetching weather data.
def get_weather(location):
"""Retrieves the current weather for a given location."""
print("Calling get_weather function with location: ", location)
# In a real application, you would call an external weather API here.
# This is a simplified example returning hardcoded data.
return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})
2. API-Anfrage mit Tools und Benutzernachricht erstellen
Erstellen Sie nun die API-Anfrage an den Novita-Endpunkt. Diese Anfrage enthält den tools-Parameter, der die Funktionen definiert, die das Modell verwenden kann, sowie die Nachricht des Benutzers.
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather of an location, the user shoud supply a location first",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA",
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "What is the weather in San Francisco?"
}
]
# Let's send the request and print the response.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Please check if the response contains tool calls if in production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
3. Ausgabe
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
- Mit dem Ergebnis des Funktionsaufrufs antworten und die endgültige Antwort erhalten
Der nächste Schritt besteht darin, den Funktionsaufruf zu verarbeiten, die get_weather-Funktion auszuführen und das Ergebnis zurück an das Modell zu senden, um die endgültige Antwort für den Benutzer zu generieren.
# Ensure tool_call is defined from the previous step
if tool_call:
# Extend conversation history with the assistant's tool call message
messages.append(response.choices[0].message)
function_name = tool_call.function.name
if function_name == "get_weather":
function_args = json.loads(tool_call.function.arguments)
# Execute the function and get the response
function_response = get_weather(
location=function_args.get("location"))
# Append the function response to the messages
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Get the final response from the model, now with the function result
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Note: Do not include tools parameter here.
)
print(answer_response.choices[0].message)
5. Ausgabe
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
Mit seinem modernen Design und der nahtlosen Integration über Novita AI übertrifft Llama 4 Maverick andere Modelle und bietet eine leistungsstarke, zuverlässige und flexible Lösung für moderne KI-gesteuerte Anwendungen.
Häufig gestellte Fragen
Was ist Function Calling?
Es ermöglicht LLMs, externe Tools oder APIs auszulösen, um Aufgaben auszuführen und Daten abzurufen.
Wie funktioniert Llama 4 Maverick mit Function Calling?
Llama 4 Maverick vereinfacht Echtzeit-Systemintegrationen über Novita AI.
Was macht Llama 4 Maverick überlegen?
Llama 4 Maverick verfügt über 400B Parameter, 128 Mixture-of-Experts und robuste mehrsprachige/multimodale Fähigkeiten, was es leistungsfähiger und vielseitiger als andere Modelle macht.
Novita AI ist die All-in-One-Cloud-Plattform, die Ihre KI-Ambitionen fördert. Integrierte APIs, serverlose Dienste, GPU-Instanzen – die kostengünstigen Tools, die Sie brauchen. Infrastruktur entfällt, starten Sie kostenlos und verwirklichen Sie Ihre KI-Vision.
