Usando a API Ollama em Python

🚀 Convite para experimentar: o primeiro software de programação inteligente AI IDE da China Download da versão chinesa do TraeO DeepSeek-R1 e o Doubao-pro estão disponíveis em uma base ilimitada!

Neste artigo, explicaremos brevemente como usar o Ollama Se você deseja ter uma simples conversa por chat, trabalhar com big data usando respostas de streaming ou criar, copiar, excluir modelos etc. localmente, este artigo pode orientá-lo. Além disso, mostramos como usar clientes personalizados e programação assíncrona para otimizar o desempenho do seu aplicativo. Além disso, mostramos como usar clientes personalizados e programação assíncrona para otimizar o desempenho do seu aplicativo. Quer você seja novo no Ollama ou um desenvolvedor experiente, este artigo o ajudará a usar a API do Ollama com mais eficiência em Python.

Este tutorial também fornece um Bloco de notas Jupyter Exemplos para melhorar.

Preparação ambiental

Antes de começar a usar o Python para interagir com a API do Ollama, verifique se o seu ambiente de desenvolvimento atende às seguintes condições:

Python: instale o Python 3.8 ou posterior.
pip: certifique-se de que você tenha o pip, a ferramenta de gerenciamento de pacotes Python, instalado.
Biblioteca ollama: usada para facilitar a interação com a API Ollama. O comando de instalação é o seguinte:

pip install ollama

Uso

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)

resposta de streaming

Isso pode ser feito definindo o stream=True Habilite o fluxo de resposta para que a chamada de função retorne um gerador Python em que cada parte seja um objeto no fluxo.

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)

Saída estruturada

Saída normal (saída não estruturada)
- Geração direta de texto em linguagem natural.
- Adequado para leitura humana, mas não para análise programática ou processamento automatizado.
- Exemplo:
```
这是一只黑色的小猫，它正在草地上玩耍。
```
Saída estruturada
- Retorna dados em JSON, YAML, XML ou outros formatos para facilitar a análise e o uso pelas máquinas.
- Ideal para APIs, fluxos de trabalho automatizados e armazenamento de dados.
- Exemplo:
```
{
"description": "这是一只黑色的小猫",
"activity": "正在草地上玩耍"
}
```

Vantagens da saída estruturada

(1) Facilidade de manuseio

A máquina pode extrair facilmente campos específicos, como description talvez activity A NLP é uma nova maneira de analisar textos comuns sem a necessidade de NLP.

(2) Melhoria da capacidade de controle

Os formatos estruturados permitem que os desenvolvedores controlem com precisão a saída do modelo e evitem respostas longas ou imprevisíveis.

Por exemplo, quando a IA gera código:

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

(3) Fácil de armazenar e analisar

Os dados estruturados são mais adequados para serem armazenados em um banco de dados para facilitar a consulta e a análise.

Exemplo:

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

A biblioteca Ollama Python oferece um rico conjunto de interfaces que simplificam a interação com o Ollama. Essas interfaces foram projetadas para serem intuitivas e fáceis de integrar, e têm o objetivo de ajudar os desenvolvedores a chamar e gerenciar modelos com mais facilidade. Para obter uma visão mais detalhada da implementação subjacente e informações completas sobre o ponto de extremidade da API, recomendamos o Guia do usuário da API da Ollama.

bate-papos

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

gerando

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

Lista de modelos locais

ollama.list()

Exibição de informações do modelo

ollama.show('llama3.1')

Criação de modelos

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

Modelos de replicação

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

Excluir modelo

ollama.delete('llama3.1')

modelo de tração

ollama.pull('llama3.1')

modelo push

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

Gerar incorporação

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

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

curso

ollama.ps()

Clientes personalizados

Isso pode ser feito passando o parâmetro ollama instanciado Client talvez AsyncClient para criar um cliente personalizado.

Clientes personalizados podem ser criados usando os seguintes campos:

hosthost Ollama ao qual se conectar
timeout:: Tempo limite da solicitação

Para todos os parâmetros de palavra-chave, consultehttpx.Client.

Cliente de sincronização

O cliente de sincronização é usado (Client) significa que quando você chama client.chat() o programa aguardará a conclusão da solicitação e retornará o resultado antes de continuar a executar o código subsequente. Essa abordagem é mais intuitiva e simples, e é adequada para a criação de aplicativos que tenham um fluxo mais linear e não precisem lidar com um grande número de tarefas simultâneas.

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 assíncrono

Esse código usa um cliente assíncrono (AsyncClient) e define uma função assíncrona chat() . Com a palavra-chave await, você pode pausar a execução da função até que o AsyncClient().chat() é concluída, mas não bloqueia outras operações nesse meio tempo. Isso é útil para o processamento eficiente de I/O operações (por exemplo, solicitações de rede) ou para aplicativos que desejam executar várias tarefas simultaneamente. Além disso, o uso do asyncio.run(chat()) para executar essa função assí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())

configurar stream=True Modifica a função para retornar um gerador assíncrono 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())

Teste de comparação de consumo de tempo de cliente síncrono e assíncrono com diferentes números de chamadas

O trecho de código a seguir chama as repetições síncronas e assíncronas do cliente, respectivamente test_num O usuário pode alterar os seguintes parâmetros do teste para comparar o tempo total necessário e o tempo necessário para uma única sessão do processo do questionário:

test_messages: dados de teste
test_num: número de testes
model_name: modelo de teste

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

incorreto

Será gerado um erro se a solicitação retornar um status de erro ou se for detectado um erro durante o streaming.

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 a documentação:Ollama python