Verwendung der Ollama-API in Python

In diesem Artikel wird kurz erklärt, wie man die Ollama Egal, ob Sie eine einfache Chat-Konversation führen, mit großen Datenmengen unter Verwendung von Streaming-Antworten arbeiten oder Modelle lokal erstellen, kopieren, löschen usw. möchten, dieser Artikel hilft Ihnen dabei. Außerdem zeigen wir Ihnen, wie Sie benutzerdefinierte Clients und asynchrone Programmierung einsetzen können, um die Leistung Ihrer Anwendung zu optimieren - egal, ob Sie neu bei Ollama sind oder ein erfahrener Entwickler, dieser Artikel wird Ihnen helfen, die Ollama-API in Python effizienter zu nutzen.

Dieses Tutorial bietet auch eine Jupyter-Notebook Beispiele, um besser zu werden.

Vorbereitung der Umwelt

Bevor Sie beginnen, Python für die Interaktion mit der Ollama-API zu verwenden, stellen Sie sicher, dass Ihre Entwicklungsumgebung die folgenden Bedingungen erfüllt:

• Python: Installieren Sie Python 3.8 oder höher.
• pip: Stellen Sie sicher, dass Sie pip, das Python-Paketverwaltungswerkzeug, installiert haben.
• ollama Library: Wird verwendet, um die Interaktion mit der Ollama API zu erleichtern. Der Installationsbefehl lautet wie folgt:

pip install ollama

Verwendung

von ollama importieren chat
from ollama import ChatResponse
response: ChatResponse = chat(model='ollama3.1', messages=[
{

content': 'Warum ist der Himmel blau?' ,
},
])
print(antwort['nachricht']['inhalt'])
print(antwort.nachricht.inhalt)

Streaming-Antwort

Dies kann durch das Setzen des Parameters stream=True Aktivieren Sie das Antwort-Streaming, damit der Funktionsaufruf einen Python-Generator zurückgibt, bei dem jeder Teil ein Objekt im Stream ist.

von ollama import chat
stream = chat(
model='ollama3.1', [{'role': 'user', 'content': 'Warum ist der Himmel blau?
messages=[{'role': 'user', 'content': 'Warum ist der Himmel blau?'}] ,
stream=True, )
)
for chunk in stream.
print(chunk['message']['content'], end='', flush=True)

Strukturierte Ausgabe

• Normale Ausgabe (unstrukturierte Ausgabe)
  • Direkte Generierung von Texten in natürlicher Sprache.
  • Geeignet für menschliches Lesen, aber nicht für programmatisches Parsing oder automatische Verarbeitung.
  • Beispiel:

    Es war ein schwarzes Kätzchen, das im Gras spielte.
    

• Strukturierte Ausgabe
  • Gibt Daten in JSON, YAML, XML oder anderen Formaten zurück, damit sie von Maschinen leichter geparst und verwendet werden können.
  • Ideal für APIs, automatisierte Arbeitsabläufe und Datenspeicherung.
  • Beispiel:

    {
    "Beschreibung": "Dies ist eine schwarz gestromte Katze",
    "activity": "Spielt im Gras."
    }
    

Vorteile der strukturierten Ausgabe

(1) Leichte Handhabung

• Die Maschine kann problemlos bestimmte Felder extrahieren, wie z. B. Beschreibung vielleicht Tätigkeit Das NLP ist eine neue Art, gewöhnlichen Text zu analysieren, ohne dass dafür NLP erforderlich ist.

(2) Verbesserung der Kontrollierbarkeit

• Strukturierte Formate ermöglichen es den Entwicklern, die Modellausgabe genau zu steuern und langwierige oder unvorhersehbare Antworten zu vermeiden.
• Zum Beispiel, wenn AI Code erzeugt:

  {
  "Sprache": "Python", "Code": "print('Hallo, Welt!')
  "code": "print('Hallo, Welt!')"
  }
  

(3) Einfach zu speichern und zu analysieren

• Strukturierte Daten eignen sich besser für die Speicherung in einer Datenbank, die eine einfache Abfrage und Analyse ermöglicht.
• Beispiel:

  {
  "Datum": "2025-01-20".
  "summary": "Today's sales are up 10%."
  }
  

von pydantic importieren BaseModel, Feld
von ollama importieren chat
importieren json
class CountryInfo(BaseModel).
capital: str = Field(... , alias="Hauptstadt")
number: str = Feld(... , alias="Einwohnerzahl")
area: str = Field(... , alias="Gebiet")
response = chat(
model='llama3.1',
messages=[{
'role': 'user', 'content': 'introduce', 'content'.
content': "Bitte stellen Sie Informationen über die Hauptstadt, die Bevölkerung und die Fläche der Vereinigten Staaten dar und geben Sie sie im JSON-Format zurück."
}]
format="json",
options={'temperature': 0}, )
)
response_content = response["message"]["content"]
if not response_content: raise ValueError("Ollama Return JSR")
raise ValueError("Das von Ollama zurückgegebene JSON ist leer")
json_response = json.loads(response_content)
print(json_response)
Freunde_Antwort = CountryInfo.model_validate(json_Antwort)
print(Freunde_Antwort)

API

Die Ollama Python-Bibliothek bietet eine Reihe von Schnittstellen, die die Interaktion mit Ollama vereinfachen. Diese Schnittstellen sind so konzipiert, dass sie intuitiv und einfach zu integrieren sind. Sie sollen Entwicklern helfen, Modelle einfacher aufzurufen und zu verwalten. Für einen detaillierteren Blick auf die zugrundeliegende Implementierung und vollständige API-Endpunktinformationen empfehlen wir die Ollama API Benutzerhandbuch.

Chats

ollama.chat(model='ollama3.1', messages=[{'role': 'user', 'content': 'Warum ist der Himmel blau?'}])

Erzeugung von

ollama.generate(model='ollama3.1', prompt='Warum ist der Himmel blau?')

Liste der lokalen Modelle

ollama.list()

Anzeige von Modellinformationen

ollama.show('llama3.1')

Modelle erstellen

modelfile='''
FROM llama3.1
SYSTEM Du bist Mario aus Super Mario Bros.
'''
ollama.create(model='example', modelfile=modelfile)

Replikationsmodelle

ollama.copy('llama3.1', 'user/llama3.1')

Modell löschen

ollama.delete('llama3.1')

Pull-Modell

ollama.pull('llama3.1')

Push-Modell

ollama.push('user/llama3.1')

Einbettung generieren

ollama.embeddings(model='llama3.1', prompt='Der Himmel ist blau aufgrund von Rayleigh-Streuung')

# Batch-Generierung der Einbettung
ollama.embed(model='llama3.1', input=['Himmel ist blau', 'Gras ist grün'])

Kurs

ollama.ps()

Kundenspezifische Kunden

Dies kann durch die Übergabe der ollama instanziiert Kunde vielleicht AsyncClient um einen benutzerdefinierten Client zu erstellen.

Benutzerdefinierte Kunden können mit Hilfe der folgenden Felder erstellt werden:

• GastgeberOllama-Host zum Verbinden mit
• Timeout:: Zeitüberschreitung der Anfrage

Für alle Schlüsselwortargumente siehehttpx.Client.

Sync-Client

Der Synchronisations-Client wird verwendet (Kunde) bedeutet, dass Sie beim Aufruf von client.chat() Methode wartet das Programm, bis die Anfrage abgeschlossen ist, und gibt das Ergebnis zurück, bevor es mit der Ausführung des nachfolgenden Codes fortfährt. Dieser Ansatz ist intuitiver und einfacher und eignet sich für das Schreiben von Anwendungen, die einen eher linearen Ablauf haben und nicht eine große Anzahl von gleichzeitigen Aufgaben bewältigen müssen.

from ollama import Client
client = Client(
host='http://localhost:11434',
headers={'x-some-header': 'some-value'}
)
response = client.chat(model='ollama3.1', messages=[
{
'role': 'user', 'content': 'why-sky'.
'content': 'Warum ist der Himmel blau?' ,
},
])
print(Antwort)

Asynchroner Client

Dieser Code verwendet einen asynchronen Client (AsyncClient) und definiert eine asynchrone Funktion chat() . Mit dem Schlüsselwort await können Sie die Ausführung der Funktion unterbrechen, bis die AsyncClient().chat() Die Anfrage wird abgeschlossen, ohne dass in der Zwischenzeit andere Vorgänge blockiert werden. Dies ist nützlich für eine effiziente Verarbeitung E/A Operationen (z. B. Netzanfragen) oder für Anwendungen, die mehrere Aufgaben gleichzeitig ausführen wollen. Darüber hinaus ist die Verwendung des asyncio.run(chat()) um diese asynchrone Funktion auszuführen.

asyncio importieren
von ollama importieren AsyncClient
importiere nest_asyncio
nest_asyncio.apply()
async def chat().
message = {'role': 'user', 'content': 'Warum ist der Himmel blau?'}
response = await AsyncClient().chat(model='llama3.1', messages=[message])
print(Antwort)
asyncio.run(chat())

aufstellen stream=True Ändert die Funktion so, dass sie einen asynchronen Python-Generator zurückgibt:

asyncio importieren
von ollama importieren AsyncClient
importiere nest_asyncio
nest_asyncio.apply()
async def chat().
message = {'role': 'user', 'content': 'Warum ist der Himmel blau?'}
async for part in await AsyncClient().chat(model='llama3.1', message=[message], stream=True):
print(part['message']['content'], end='', flush=True)
asyncio.run(chat())

Vergleichstest des Zeitverbrauchs von synchronen und asynchronen Clients bei unterschiedlicher Anzahl von Aufrufen

Das folgende Codestück ruft die synchronen bzw. asynchronen Client-Repeats auf test_num Der Benutzer kann die folgenden Parameter für den Test ändern, um die benötigte Gesamtzeit und die Zeit, die für eine einzelne Sitzung des Quizprozesses benötigt wird, zu vergleichen:

• test_messages: Testdaten
• test_num: Anzahl der Tests
• model_name: Testmodell

Zeit importieren
importieren asyncio
von ollama importieren Client, AsyncClient
importieren nest_asyncio
# Anwendung von nest_asyncio zur Unterstützung asynchroner Operationen in Jupyter
nest_asyncio.apply()
# Initialisieren des Clients
client = Client(host='http://localhost:11434')
async_client = AsyncClient(host='http://localhost:11434')
# Handler für Synchronisierungsanfragen
def request_example(client, model_name, messages):
start_time = time.time()
start_time = time.time()
#-Sync-Anfrage Rückgabe
response = client.chat(model=model_name, messages=messages)
except Exception as e.
print(f "Sync-Anfrage fehlgeschlagen: {e}")
response = Keine
end_time = time.time()
Dauer = end_time - start_time
duration = end_time - start_time print(f "Zeit der Synchronisationsanfrage: {duration}")
Antwort, Dauer zurückgeben
# Asynchroner Anfrage-Handler
async def async_request_example(client, model_name, messages):
start_time = time.time()
start_time = time.time(): start_time = time.time()
# asynchrone Anfrage Rückgabe
response = await client.chat(model=model_name, messages=messages)
except Exception as e.
print(f "Asynchrone Anfrage fehlgeschlagen: {e}")
response = Keine
end_time = time.time()
Dauer = end_time - start_time
print(f "Dauer der asynchronen Anfrage: {Dauer}")
return Antwort, Dauer
# Asynchrone Anfrage Testfunktion
async def async_client_test(test_num, model_name, messages):
tasks = [asyncio.create_task(async_request_example(async_client, model_name, messages))
for _ in range(test_num)]
results= await asyncio.gather(*tasks)
return results
# Ausführen des Sync-Tests
def sync_test(model_name, messages, test_num): total_time = 0
gesamt_zeit = 0
for i in range(test_num): _, duration = anfrage_beispiel = 0
_, duration = request_example(client, model_name, messages)
gesamt_zeit += dauer
return gesamt_zeit / test_num
# Einen asynchronen Test ausführen
async def async_test(model_name, messages, test_num):: start_time = time.
start_time = time.time()
await async_client_test(test_num, model_name, messages)
end_time = time.time()
return (end_time - start_time) / test_num
# Bereiten Sie die Testdaten vor
test_messages = [{'role': 'user', 'content': 'Warum ist der Himmel blau?'}]
test_num = 10
model_name = 'llama3.1'
# Führen Sie den Synchronisationstest durch und geben Sie die Ergebnisse aus
print("Durchführung des Synchronisationstests")
sync_avg_time = sync_test(model_name, test_messages, test_num)
print(f "Durchschnittliche Zeit des Synchronisierungstests: {sync_avg_time:.2f} Sekunden")
# Führen Sie den asynchronen Test durch und geben Sie die Ergebnisse aus
print("Asynchroner Test läuft")
async_avg_time = asyncio.run(async_test(model_name, test_messages, test_num))
print(f "Asynchroner Test durchschnittliche Zeit: {async_avg_time:.2f} Sekunden")

falsch

Ein Fehler wird ausgelöst, wenn die Anforderung einen Fehlerstatus zurückgibt oder ein Fehler beim Streaming festgestellt wird.

ollama importieren
model = 'noch-nicht-existent'
versuchen.
ollama.chat(model)
except ollama.ResponseError as e:: print('Fehler:', e.error)
print('Fehler:', e.error)
print('Fehler:', e.error) if e.status_code == 404: ollama.pull(model): ollama.
ollama.pull(model)

Siehe dazu die Dokumentation:Ollama-Python