Uso de la API de Ollama en Python

En este artículo, describiremos brevemente cómo utilizar la función Ollama Tanto si quieres mantener una simple conversación de chat, como si quieres trabajar con big data utilizando respuestas en streaming, o si quieres realizar la creación, copia, borrado, etc. de modelos de forma local, este artículo puede guiarte. Además, mostramos cómo utilizar clientes personalizados y programación asíncrona para optimizar el rendimiento de tu aplicación.Tanto si eres nuevo en Ollama como si eres un desarrollador experimentado, este artículo te ayudará a utilizar la API de Ollama de forma más eficiente en Python.

Este tutorial también ofrece una Cuaderno Jupyter Ejemplos para mejorar.

Preparación medioambiental

Antes de empezar a utilizar Python para interactuar con la API de Ollama, asegúrese de que su entorno de desarrollo cumple las siguientes condiciones:

• Python: Instale Python 3.8 o posterior.
• pip: Asegúrese de tener instalado pip, la herramienta de gestión de paquetes de Python.
• Librería ollama: Se utiliza para facilitar la interacción con la API de Ollama. El comando de instalación es el siguiente:

pip install ollama

Utilización

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)

respuesta en tiempo real

Esto se puede hacer configurando la opción stream=True Habilitar el flujo de respuesta para que la llamada a la función devuelva un generador Python donde cada parte es un objeto del flujo.

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)

Salida estructurada

• Salida normal (salida no estructurada)
  • Generación directa de texto en lenguaje natural.
  • Apto para lectura humana, pero no para análisis sintáctico programático o tratamiento automatizado.
  • Por ejemplo:

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

• Salida estructurada
  • Devuelve los datos en JSON, YAML, XML u otros formatos para que las máquinas puedan analizarlos y utilizarlos más fácilmente.
  • Ideal para API, flujos de trabajo automatizados y almacenamiento de datos.
  • Por ejemplo:

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

Ventajas de la salida estructurada

(1) Facilidad de manejo

• La máquina puede extraer fácilmente campos específicos como description tal vez activity La PNL es una nueva forma de analizar texto ordinario sin necesidad de PNL.

(2) Mejora de la controlabilidad

• Los formatos estructurados permiten a los desarrolladores controlar con precisión los resultados del modelo y evitar respuestas largas o imprevisibles.
• Por ejemplo, cuando la IA genera código:

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

(3) Fácil de almacenar y analizar

• Los datos estructurados se almacenan mejor en una base de datos para facilitar su consulta y análisis.
• Por ejemplo:

  {
  "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 biblioteca Python de Ollama proporciona un rico conjunto de interfaces que simplifican la interacción con Ollama. Estas interfaces están diseñadas para ser intuitivas y fáciles de integrar, y están pensadas para ayudar a los desarrolladores a llamar y gestionar modelos más fácilmente. Para obtener una visión más detallada de la implementación subyacente e información completa sobre los puntos finales de la API, recomendamos el sitio web Guía del usuario de la API de Ollama.

chats

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

generando

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

Lista de modelos locales

ollama.list()

Visualización de la información sobre el modelo

ollama.show('llama3.1')

Creación de modelos

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

Modelos de réplica

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

Borrar modelo

ollama.delete('llama3.1')

modelo pull

ollama.pull('llama3.1')

modelo push

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

Generar incrustación

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

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

curso

ollama.ps()

Clientes a medida

Esto puede hacerse pasando la variable ollama instanciado Client tal vez AsyncClient para crear un cliente personalizado.

Se pueden crear clientes personalizados utilizando los siguientes campos:

• hosthost Ollama al que conectarse
• timeout:: Tiempo de espera de la solicitud

Para todos los argumentos de palabras clave, véasehttpx.Client.

Cliente de sincronización

Se utiliza el cliente de sincronización (Client) significa que cuando se llama a client.chat() el programa esperará a que se complete la petición y devolverá el resultado antes de continuar con la ejecución del código siguiente. Este enfoque es más intuitivo y sencillo, y resulta adecuado para escribir aplicaciones que tengan un flujo más lineal y no necesiten manejar un gran número de tareas concurrentes.

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)

Cliente asíncrono

Este código utiliza un cliente asíncrono (AsyncClient) y define una función asíncrona chat() . Con la palabra clave await, puede pausar la ejecución de la función hasta que el AsyncClient().chat() pero sin bloquear otras operaciones mientras tanto. Esto es útil para procesar eficientemente I/O operaciones (por ejemplo, solicitudes de red) o para aplicaciones que desean realizar varias tareas simultáneamente. Además, el uso de la asyncio.run(chat()) para ejecutar esta función asíncrona.

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

establecer stream=True Modifica la función para devolver un generador asíncrono de 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())

Prueba comparativa de consumo de tiempo de cliente síncrono y asíncrono con distinto número de llamadas

El siguiente fragmento de código llama a las repeticiones síncrona y asíncrona del cliente, respectivamente test_num El usuario puede cambiar los siguientes parámetros de la prueba para comparar el tiempo total requerido y el tiempo requerido para una sola sesión del proceso de la prueba:

• test_messages: datos de prueba
• test_num: número de pruebas
• nombre_modelo: modelo de prueba

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

incorrecto

Se produce un error si la solicitud devuelve un estado de error o se detecta un error durante la transmisión.

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)

Consulte la documentación:Pitón de Ollama