Funktionsaufrufe mit Ollama, Llama 3.2 und Milvus
Aktualisiert am 25. September 2024 mit Llama 3.2.
Funktionsaufrufe mit LLMs sind so, als würden Sie Ihrer KI die Möglichkeit geben, sich mit der Welt zu verbinden. Durch die Integration Ihres LLM mit externen Tools wie benutzerdefinierten Funktionen oder APIs können Sie Anwendungen erstellen, die reale Probleme lösen.
In diesem Blogbeitrag wird gezeigt, wie Llama 3.2 mit externen Tools wie [Milvus] (https://zilliz.com/what-is-milvus) und APIs integriert werden kann, um leistungsstarke, kontextbezogene Anwendungen zu erstellen.
Einführung in Funktionsaufrufe
LLMs wie GPT-4, Mistral Nemo und Llama 3.2 können jetzt erkennen, wann sie eine Funktion aufrufen müssen und dann JSON mit Argumenten ausgeben, um diese Funktion aufzurufen. Dies macht Ihre KI-Anwendungen vielseitiger und leistungsfähiger.
Funktionsaufrufe ermöglichen es Entwicklern, zu erstellen:
LLM-gestützte Lösungen zum Extrahieren und Verschlagworten von Daten (z. B. Extrahieren von Personennamen aus einem Wikipedia-Artikel)
Anwendungen, die bei der Umwandlung natürlicher Sprache in API-Aufrufe oder gültige Datenbankabfragen helfen können
konversationelle Wissensabfrage-Maschinen, die mit einer Wissensbasis interagieren
Die Werkzeuge
Ollama: Bringt die Leistung von LLMs auf Ihren Laptop und vereinfacht die lokale Bedienung.
Milvus: Unsere bevorzugte Vektordatenbank für effiziente Datenspeicherung und -abfrage.
Llama 3.2-3B: Die aktualisierte Version des 3.1-Modells ist mehrsprachig, hat eine deutlich größere Kontextlänge von 128K und kann die Verwendung von Tools nutzen.
Verwendung von Llama 3.2 und Ollama
Llama 3.2 wurde in Bezug auf Funktionsaufrufe feinabgestimmt. Es unterstützt einzelne, verschachtelte und parallele Funktionsaufrufe, sowie Funktionsaufrufe mit mehreren Schritten. Das bedeutet, dass Ihre KI komplexe Aufgaben bewältigen kann, die mehrere Schritte oder parallele Prozesse umfassen.
In unserem Beispiel werden wir verschiedene Funktionen implementieren, um einen API-Aufruf zur Abfrage von Flugzeiten zu simulieren und eine Suche in Milvus durchzuführen. Llama 3.2 entscheidet anhand der Anfrage des Benutzers, welche Funktion aufgerufen werden soll.
Abhängigkeiten installieren
Lassen Sie uns zuerst alles einrichten. Laden Sie Llama 3.2 mit Ollama herunter:
ollama run llama3.2
Dadurch wird das Modell auf Ihren Laptop heruntergeladen und ist damit bereit für die Verwendung mit Ollama. Als nächstes installieren Sie die notwendigen Abhängigkeiten:
! pip install ollama openai "pymilvus[model]"
Wir installieren Milvus Lite mit der Modellerweiterung, die es Ihnen ermöglicht, Daten mit Hilfe der in Milvus verfügbaren Modelle einzubetten.
Daten in Milvus einfügen
Fügen wir nun einige Daten in Milvus ein. Dies sind die Daten, nach denen Llama 3.2 später suchen wird, wenn es sie für relevant hält!
Erstellen und Einfügen der Daten
von pymilvus import MilvusClient, model
Einbettung_fn = model.DefaultEmbeddingFunction()
docs = [
"Künstliche Intelligenz wurde 1956 als akademische Disziplin gegründet.",
"Alan Turing war die erste Person, die umfangreiche Forschungen auf dem Gebiet der KI durchführte.",
"Geboren in Maida Vale, London, wuchs Turing in Südengland auf.",
]
vectors = embedding_fn.encode_documents(docs)
# Der Ausgabevektor hat 768 Dimensionen, was der gerade erstellten Sammlung entspricht.
print("Dim:", embedding_fn.dim, vectors[0].shape) # Dim: 768 (768,)
# Jede Entität hat eine Kennung, eine Vektordarstellung, einen Rohtext und eine Themenbezeichnung.
data = [
{"id": i, "vector": vectors[i], "text": docs[i], "subject": "Geschichte"}
for i in range(len(vectors))
]
print("Data has", len(data), "entities, each with fields: ", data[0].keys())
print("Vektor dim:", len(data[0]["vector"]))
# Erstellen Sie eine Sammlung und fügen Sie die Daten ein
client = MilvusClient('./milvus_local.db')
client.create_collection(
collection_name="demo_collection",
dimension=768, # Die Vektoren, die wir in dieser Demo verwenden, haben 768 Dimensionen
)
client.insert(collection_name="demo_collection", data=data)
Sie sollten nun 3 Elemente in Ihrer neuen Sammlung haben.
Definieren Sie die zu verwendenden Funktionen
In diesem Beispiel werden wir zwei Funktionen definieren. Die erste simuliert einen API-Aufruf zum Abrufen von Flugzeiten. Die zweite führt eine Suchanfrage in Milvus aus.
von pymilvus importieren model
importiere json
importieren ollama
einbetten_fn = model.DefaultEmbeddingFunction()
# Simuliert einen API-Aufruf, um Flugzeiten zu erhalten.
# In einer realen Anwendung würde dies Daten aus einer Live-Datenbank oder API abrufen
def get_flight_times(departure: str, arrival: str) -> str:
flights = {
'NYC-LAX': {'Abflug': '08:00 AM', 'Ankunft': '11:30 AM', 'Dauer': '5h 30m'},
'LAX-NYC': {'Abflug': '02:00 PM', 'Ankunft': '10:30 PM', 'Dauer': '5h 30m'},
'LHR-JFK': {'Abflug': '10:00 AM', 'Ankunft': '01:00 PM', 'Dauer': '8h 00m'},
'JFK-LHR': {'Abflug': '09:00 PM', 'Ankunft': '09:00 AM', 'Dauer': '7h 00m'},
'CDG-DXB': {'Abflug': '11:00 AM', 'Ankunft': '08:00 PM', 'Dauer': '6h 00m'},
'DXB-CDG': {'Abflug': '03:00 AM', 'Ankunft': '07:30 AM', 'Dauer': '7h 30m'},
}
key = f'{Abflug}-{Ankunft}'.upper()
return json.dumps(flights.get(key, {'error': 'Flug nicht gefunden'}))
# Suche nach Daten im Zusammenhang mit Künstlicher Intelligenz in einer Vektordatenbank
def search_data_in_vector_db(query: str) -> str:
query_vectors = embedding_fn.encode_queries([query])
res = client.search(
collection_name="demo_collection",
data=query_vectors,
limit=2,
output_fields=["text", "subject"], # gibt die zurückzugebenden Felder an
)
print(res)
return json.dumps(res)
Geben Sie dem LLM die Anweisungen, damit er diese Funktionen verwenden kann
Geben wir nun dem LLM die Anweisungen, damit er die von uns definierten Funktionen verwenden kann.
def run(model: str, question: str):
client = ollama.Client()
# Konversation mit einer Benutzerabfrage initialisieren
messages = [{"role": "user", "content": question}]
# Erster API-Aufruf: Senden Sie die Abfrage und die Funktionsbeschreibung an das Modell
response = client.chat(
model=model,
messages=messages,
tools=[
{
"type": "function",
"function": {
"name": "get_flight_times",
"description": "Ermittelt die Flugzeiten zwischen zwei Städten",
"parameters": {
"type": "object",
"properties": {
"departure": {
"type": "string",
"description": "Die Abflugstadt (Flughafencode)",
},
"Ankunft": {
"Typ": "string",
"description": "Die Ankunftsstadt (Flughafencode)",
},
},
"required": ["Abflug", "Ankunft"],
},
},
},
{
"Typ": "function",
"function": {
"name": "search_data_in_vector_db",
"description": "Suche über Daten der Künstlichen Intelligenz in einer Vektordatenbank",
"Parameter": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Die Suchanfrage",
},
},
"erforderlich": ["query"],
},
},
},
],
)
# Hinzufügen der Antwort des Modells zum Gesprächsverlauf
messages.append(response["message"])
# Prüfen Sie, ob das Modell die angegebene Funktion verwenden will.
if not response["message"].get("tool_calls"):
print("Das Modell hat die Funktion nicht verwendet. Seine Antwort war:")
print(antwort["nachricht"]["inhalt"])
return
# Funktionsaufrufe des Modells verarbeiten
if response["message"].get("tool_calls"):
available_functions = {
"get_flight_times": get_flight_times,
"search_data_in_vector_db": search_data_in_vector_db,
}
for tool in response["message"]["tool_calls"]:
function_to_call = available_functions[tool["function"]["name"]]
function_args = tool["function"]["arguments"]
function_response = function_to_call(**function_args)
# Funktionsantwort zur Konversation hinzufügen
messages.append(
{
"role": "tool",
"Inhalt": function_response,
}
)
# Zweiter API-Aufruf: Abrufen der endgültigen Antwort aus dem Modell
final_response = client.chat(model=model, messages=messages)
print(final_response["message"]["content"])
Beispielverwendung
Prüfen wir, ob wir die Zeit für einen bestimmten Flug ermitteln können:
question = "Wie lang ist die Flugzeit von New York (NYC) nach Los Angeles (LAX)?"
run('llama3.2', Frage)
Das Ergebnis ist:
Die Flugzeit von New York (JFK/LGA/EWR) nach Los Angeles (LAX) beträgt etwa 5 Stunden und 30 Minuten. Bitte beachten Sie jedoch, dass diese Zeit je nach Fluggesellschaft, Flugplan und eventuellen Zwischenlandungen oder Verspätungen variieren kann. Erkundigen Sie sich am besten immer bei Ihrer Fluggesellschaft nach den aktuellsten und genauesten Fluginformationen.
Jetzt wollen wir mal sehen, ob Llama 3.2 eine Vektorsuche mit Milvus durchführen kann.
question = "Wann wurde die Künstliche Intelligenz gegründet?"
run("llama3.2", Frage)
Das Ergebnis ist eine Milvus-Suche:
Daten: ["[{'id': 0, 'distance': 0.5738513469696045, 'entity': {'text': 'Künstliche Intelligenz wurde 1956 als akademische Disziplin gegründet.', 'subject': 'history'}}, {'id': 1, 'distance': 0.4090226888656616, 'entity': {'text': 'Alan Turing war die erste Person, die umfangreiche Forschungen im Bereich der KI durchführte.', 'subject': 'history'}}]"]
Künstliche Intelligenz wurde 1956 als akademische Disziplin gegründet.
Schlussfolgerung
Funktionsaufrufe mit LLMs eröffnen eine Welt der Möglichkeiten. Durch die Integration von Llama 3.2 mit externen Tools wie Milvus und APIs können Sie leistungsstarke, kontextbezogene Anwendungen erstellen, die auf spezifische Anwendungsfälle und praktische Probleme zugeschnitten sind.
Schauen Sie sich [Milvus] (https://zilliz.com/what-is-milvus) und den Code auf [Github] (https://github.com/stephen37/talks/blob/main/ollama_examples/function_calling.ipynb) an, und teilen Sie Ihre Erfahrungen mit der Community, indem Sie unserem [Discord] (https://discord.gg/FG6hMJStWu) beitreten.
Stephen BatifolStephen Batifol is a Developer Advocate at Zilliz. He previously worked as a Machine Learning Engineer at Wolt, where he was working on the ML Platform and as a Data Scientist at Brevo. Stephen studied Computer Science and Artificial Intelligence. He enjoys dancing and surfing.
Weiterlesen
Data Deduplication at Trillion Scale: How to Solve the Biggest Bottleneck of LLM Training
Explore how MinHash LSH and Milvus handle data deduplication at the trillion-scale level, solving key bottlenecks in LLM training for improved AI model performance.
Democratizing AI: Making Vector Search Powerful and Affordable
Zilliz democratizes AI vector search with Milvus 2.6 and Zilliz Cloud for powerful, affordable scalability, cutting costs in infrastructure, operations, and development.
How to Use Anthropic MCP Server with Milvus
Discover how Model Context Protocol (MCP) pairs with Milvus to eliminate AI integration hassles, enabling smarter agents with seamless data access and flexibility.