Utiliser l'API Ollama en Python

Dans cet article, nous décrirons brièvement comment utiliser la fonction Ollama Que vous souhaitiez avoir une simple conversation par chat, travailler avec des big data en utilisant des réponses en streaming, ou que vous souhaitiez faire de la création, de la copie, de la suppression de modèles, etc. localement, cet article peut vous guider. En outre, nous montrons comment utiliser des clients personnalisés et la programmation asynchrone pour optimiser les performances de votre application.Que vous soyez un nouveau venu à Ollama ou un développeur expérimenté, cet article vous aidera à utiliser l'API Ollama plus efficacement en Python.

Ce tutoriel fournit également un Bloc-notes Jupyter Des exemples pour s'améliorer.

Préparation de l'environnement

Avant de commencer à utiliser Python pour interagir avec l'API Ollama, assurez-vous que votre environnement de développement remplit les conditions suivantes :

• Python : Installez Python 3.8 ou une version ultérieure.
• pip : Assurez-vous que pip, l'outil de gestion des paquets Python, est installé.
• Bibliothèque ollama : utilisée pour faciliter l'interaction avec l'API Ollama. La commande d'installation est la suivante :

pip install ollama

Utilisation

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)

réponse en continu

Pour ce faire, il suffit de définir le paramètre stream=True Activer le streaming de réponse pour que l'appel de fonction renvoie un générateur Python dont chaque partie est un objet dans le flux.

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)

Sortie structurée

• Sortie normale (sortie non structurée)
  • Génération directe de textes en langage naturel.
  • Convient à la lecture humaine, mais pas à l'analyse programmatique ou au traitement automatisé.
  • Exemple :

    这是一只黑色的小猫，它正在草地上玩耍。
    

• Sortie structurée
  • Renvoie les données dans les formats JSON, YAML, XML ou autres afin de faciliter leur analyse et leur utilisation par les machines.
  • Idéal pour les API, les flux de travail automatisés et le stockage de données.
  • Exemple :

    {
    "description": "这是一只黑色的小猫",
    "activity": "正在草地上玩耍"
    }
    

Avantages des sorties structurées

(1) Facilité de manipulation

• La machine peut facilement extraire des champs spécifiques tels que description peut-être activity Le NLP est une nouvelle façon d'analyser un texte ordinaire sans avoir recours au NLP.

(2) Amélioration de la contrôlabilité

• Les formats structurés permettent aux développeurs de contrôler précisément les résultats du modèle et d'éviter les réponses longues ou imprévisibles.
• Par exemple, lorsque l'IA génère du code :

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

(3) Facilité de stockage et d'analyse

• Les données structurées sont mieux adaptées pour être stockées dans une base de données afin de faciliter l'interrogation et l'analyse.
• Exemple :

  {
  "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

La bibliothèque Python d'Ollama fournit un ensemble riche d'interfaces qui simplifient l'interaction avec Ollama. Ces interfaces sont conçues pour être intuitives et faciles à intégrer, et sont destinées à aider les développeurs à appeler et à gérer les modèles plus facilement. Pour un aperçu plus détaillé de l'implémentation sous-jacente et des informations complètes sur les points de terminaison de l'API, nous vous recommandons de consulter le document Guide de l'utilisateur de l'API Ollama.

chats

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

générant

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

Liste des modèles locaux

ollama.list()

Affichage des informations sur le modèle

ollama.show('llama3.1')

Création de modèles

modelfile='''
FROM llama3.1
SYSTEM 你是超级马里奥兄弟中的马里奥。
'''
ollama.create(model='example', modelfile=modelfile)

Modèles de réplication

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

Supprimer le modèle

ollama.delete('llama3.1')

modèle de traction

ollama.pull('llama3.1')

modèle à pousser

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

Générer l'intégration

ollama.embeddings(model='llama3.1', prompt='天空是蓝色的因为瑞利散射')

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

cours

ollama.ps()

Clients sur mesure

Pour ce faire, il suffit de passer le paramètre ollama instancié Client peut-être AsyncClient pour créer un client personnalisé.

Les clients personnalisés peuvent être créés à l'aide des champs suivants :

• hostOllama : hôte Ollama auquel se connecter
• timeout: : Délai d'attente de la demande

Pour tous les paramètres des mots-clés, voirhttpx.Client.

Client Sync

Le client de synchronisation est utilisé (Client) signifie que lorsque vous appelez client.chat() le programme attendra la fin de la requête et renverra le résultat avant de poursuivre l'exécution du code suivant. Cette approche est plus intuitive et plus simple, et convient à l'écriture d'applications dont le flux est plus linéaire et qui n'ont pas besoin de gérer un grand nombre de tâches simultanées.

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)

Client asynchrone

Ce code utilise un client asynchrone (AsyncClient) et définit une fonction asynchrone chat() . Le mot-clé await permet d'interrompre l'exécution de la fonction jusqu'à ce que l'élément AsyncClient().chat() se termine, mais ne bloque pas d'autres opérations dans l'intervalle. Ceci est utile pour traiter efficacement les demandes de I/O L'utilisation d'un système de gestion de l'information peut également s'avérer utile pour les opérations de gestion de l'information (par exemple, les requêtes de réseau) ou pour les applications qui souhaitent effectuer plusieurs tâches simultanément. En outre, l'utilisation du asyncio.run(chat()) pour exécuter cette fonction asynchrone.

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

mettre en place stream=True Modifie la fonction pour qu'elle renvoie un générateur asynchrone Python :

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

Test de comparaison de la consommation de temps des clients synchrones et asynchrones avec différents nombres d'appels

Le morceau de code suivant appelle respectivement les répétitions synchrones et asynchrones du client test_num L'utilisateur peut modifier les paramètres suivants pour le test afin de comparer le temps total requis et le temps requis pour une seule session du processus de quiz :

• test_messages : données de test
• test_num : nombre de tests
• nom_du_modèle : modèle de test

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} 秒")

incorrect

Une erreur est levée si la demande renvoie un statut d'erreur ou si une erreur est détectée lors de la diffusion en continu.

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)

Se référer à la documentation :Ollama python