Verwendung der Ollama API in Python - Chief AI Sharing Circle

🚀 Einladung zum Erleben: Chinas erste KI-IDE Intelligente Programmiersoftware Trae Chinesische Version downloadDer DeepSeek-R1 und Doubao-pro sind unbegrenzt verfügbar!

In diesem Artikel wird kurz beschrieben, 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

from ollama import chat
from ollama import ChatResponse
response: ChatResponse = chat(model='llama3.1', messages=[
{
'role': 'user',
'content': '为什么天空是蓝色的？',
},
])
print(response['message']['content'])
print(response.message.content)

Streaming-Reaktion

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.

from ollama import chat
stream = chat(
model='llama3.1',
messages=[{'role': 'user', 'content': '为什么天空是蓝色的？'}],
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:
```
这是一只黑色的小猫，它正在草地上玩耍。
```
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:
```
{
"description": "这是一只黑色的小猫",
"activity": "正在草地上玩耍"
}
```

Vorteile der strukturierten Ausgabe

(1) Leichte Handhabung

Die Maschine kann problemlos bestimmte Felder extrahieren, wie z. B. description vielleicht activity 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:

{
"language": "Python",
"code": "print('Hello, World!')"
}

(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:

{
"date": "2025-01-20",
"summary": "今天的销售额增长了10%。"
}

from pydantic import BaseModel, Field
from ollama import chat
import json
class CountryInfo(BaseModel):
capital: str = Field(..., alias="首都")
number: str = Field(..., alias="人口")
area: str = Field(..., alias="占地面积")  
response = chat(
model='llama3.1',
messages=[{
'role': 'user',
'content': "请介绍美国的首都、人口、占地面积信息，并以 JSON 格式返回。"
}],
format="json",  
options={'temperature': 0}, 
)
response_content = response["message"]["content"]
if not response_content:
raise ValueError("Ollama 返回的 JSON 为空")
json_response = json.loads(response_content)  
print(json_response)
friends_response = CountryInfo.model_validate(json_response)  
print(friends_response)

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, und 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.

plaudern mit

ollama.chat(model='llama3.1', messages=[{'role': 'user', 'content': '为什么天空是蓝色的？'}])

Erzeugung von

ollama.generate(model='llama3.1', prompt='为什么天空是蓝色的？')

Liste der lokalen Modelle

ollama.list()

Anzeige von Modellinformationen

ollama.show('llama3.1')

Modelle erstellen

modelfile='''
FROM llama3.1
SYSTEM 你是超级马里奥兄弟中的马里奥。
'''
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='天空是蓝色的因为瑞利散射')

# 批量生成embedding
ollama.embed(model='llama3.1', input=['天空是蓝色的', '草是绿色的'])

Kurs

ollama.ps()

Kundenspezifische Kunden

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

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

hostOllama-Host zum Verbinden mit
timeout:: Zeitüberschreitung der Anfrage

Für alle Schlüsselwortparameter siehehttpx.Client.

Sync-Client

Der Synchronisations-Client wird verwendet (Client) 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='llama3.1', messages=[
{
'role': 'user',
'content': '为什么天空是蓝色的？',
},
])
print(response)

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 I/O 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.

import asyncio
from ollama import AsyncClient
import nest_asyncio
nest_asyncio.apply()
async def chat():
message = {'role': 'user', 'content': '为什么天空是蓝色的？'}
response = await AsyncClient().chat(model='llama3.1', messages=[message])
print(response)
asyncio.run(chat())

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

import asyncio
from ollama import AsyncClient
import nest_asyncio
nest_asyncio.apply()
async def chat():
message = {'role': 'user', 'content': '为什么天空是蓝色的？'}
async for part in await AsyncClient().chat(model='llama3.1', messages=[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

import time
import asyncio
from ollama import Client, AsyncClient
import nest_asyncio
# 应用nest_asyncio以支持Jupyter中的异步操作
nest_asyncio.apply()
# 初始化客户端
client = Client(host='http://localhost:11434')
async_client = AsyncClient(host='http://localhost:11434')
# 同步请求处理函数
def request_example(client, model_name, messages):
start_time = time.time()
try:
# 同步请求返回
response = client.chat(model=model_name, messages=messages)
except Exception as e:
print(f"同步请求失败: {e}")
response = None
end_time = time.time()
duration = end_time - start_time
print(f"同步请求时间: {duration}")
return response, duration
# 异步请求处理函数
async def async_request_example(client, model_name, messages):
start_time = time.time()
try:
# 异步请求返回
response = await client.chat(model=model_name, messages=messages)
except Exception as e:
print(f"异步请求失败: {e}")
response = None
end_time = time.time()
duration = end_time - start_time
print(f"异步请求时间: {duration}")
return response, duration
# 异步请求测试函数
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
# 运行同步测试
def sync_test(model_name, messages, test_num):
total_time = 0
for i in range(test_num):
_, duration = request_example(client, model_name, messages)
total_time += duration
return total_time / test_num
# 运行异步测试
async def async_test(model_name, messages, test_num):
start_time = time.time()
await async_client_test(test_num, model_name, messages)
end_time = time.time()
return (end_time - start_time) / test_num
# 准备测试数据
test_messages = [{'role': 'user', 'content': '为什么天空是蓝色的？'}]
test_num = 10
model_name = 'llama3.1'
# 运行同步测试并输出结果
print("运行同步测试")
sync_avg_time = sync_test(model_name, test_messages, test_num)
print(f"同步测试平均时间: {sync_avg_time:.2f} 秒")
# 运行异步测试并输出结果
print("运行异步测试")
async_avg_time = asyncio.run(async_test(model_name, test_messages, test_num))
print(f"异步测试平均时间: {async_avg_time:.2f} 秒")

falsch

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

import ollama
model = 'does-not-yet-exist'
try:
ollama.chat(model)
except ollama.ResponseError as e:
print('错误:', e.error)
if e.status_code == 404:
ollama.pull(model)

Siehe dazu die Dokumentation:Ollama-Python

Verwendung der Ollama-API in Python