Ollama 的代码（Python）调用

Ollama 的代码（Python）调用

简介

Python 调用 Ollama

简介

        在人工智能蓬勃发展的当下，Ollama 以其独特的魅力崭露头角。本篇深入探讨了如何借助 Python 语言高效调用 Ollama。通过详实的代码示例和深入浅出的讲解，无论是编程新手还是经验丰富的开发者，都能从中掌握利用 Python 与 Ollama 交互的技巧，挖掘 Ollama 在文本处理、模型推理等多方面的强大潜力，开启 AI 应用开发的新篇章。

        在使用 Python 调用 Ollama 之前需要先部署好环境：

• 安装 Python：博主用的是 Python 3.12.4，也可以使用一些 Python 3.8 以上的其他版本，至于为什么要用3.8以上的，是因为像 := 这类新引入的运算符是在 3.8 之后才引入的
• 安装 ollama 模块：请使用以下命令进行安装，pip 的使用方法请查看该博客：pip 的使用方法

  pip install -i https://mirrors.aliyun.com/pypi/simple/ ollama

• 确保代码调用的模型已在服务器中，不存在则会报 not found 的错误，可以使用以下命令来查看是否存在

  ollama list

Python 调用 Ollama

一、Chat —— 与模型对话

1、与模型聊天

        这是最普通的与模型进行聊天。代码如下

from ollama import chat

messages = [
  {
    'role': 'user',
    'content': 'Why is the sky blue?',    # 与模型聊天的内容
  },
]

response = chat('llama3.2', messages=messages)    # 放入 chat 方法，选择调用的模型
print(response['message']['content'])

代码输出： 

2、与远端模型聊天 

        由于大模型的使用资源消耗比较大，可能会把大模型的运行部署在远端，这是我们本地的 Python 就需要自定义客户端使它能调用远端的 Ollama API 了。

代码如下：

from ollama import Client


# 自定义客户端，并填入远端服务器地址，默认是 127.0.0.1
client = Client(host='http://192.168.31.58:11434')    # 如果需要设置链接超时，可以使用 timeout 来进行设置

messages = [
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
]

response = client.chat(model='llama3.2', messages=messages)
print(response['message']['content'])

代码输出：

3、与模型异步（非阻塞）聊天

代码如下： 

import asyncio

from ollama import AsyncClient


async def main():
  messages = [
    {
      'role': 'user',
      'content': 'Why is the sky blue?',
    },
  ]

  client = AsyncClient()
  response = await client.chat('deepseek-r1:32b', messages=messages)
  print(response['message']['content'])
  

if __name__ == '__main__':
  asyncio.run(main())

代码输出： 

4、 与远端模型异步（非阻塞）聊天

代码如下：

import asyncio

from ollama import AsyncClient


async def main():
  messages = [
    {
      'role': 'user',
      'content': 'Why is the sky blue?',
    },
  ]

  client = AsyncClient(host='http://192.168.31.58:11434')
  response = await client.chat('deepseek-r1:32b', messages=messages)
  print(response['message']['content'])


if __name__ == '__main__':
  asyncio.run(main())

代码输出：

5、聊天流式输出

代码如下： 

from ollama import chat

messages = [
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
]

for part in chat('llama3.2', messages=messages, stream=True):
  print(part['message']['content'], end='', flush=True)

print()

代码输出：

6、聊天保留聊天记录

代码如下：

from ollama import chat

messages = [
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
  {
    'role': 'assistant',
    'content': "The sky is blue because of the way the Earth's atmosphere scatters sunlight.",
  },
  {
    'role': 'user',
    'content': '你是谁?',
  },
  {
    'role': 'assistant',
    'content': "我是皮卡丘。",
  },
  {
    'role': 'user',
    'content': 'What is the weather in Tokyo?',
  },
  {
    'role': 'assistant',
    'content': 'The weather in Tokyo is typically warm and humid during the summer months, with temperatures often exceeding 30°C (86°F). The city experiences a rainy season from June to September, with heavy rainfall and occasional typhoons. Winter is mild, with temperatures rarely dropping below freezing. The city is known for its high-tech and vibrant culture, with many popular tourist attractions such as the Tokyo Tower, Senso-ji Temple, and the bustling Shibuya district.',
  },
]

while True:
  user_input = input('Chat with history: ')
  response = chat(
    'llama3.2',
    messages=messages
    + [
      {'role': 'user', 'content': user_input},
    ],
  )

  # 将回复添加到 messages 中以保留聊天记录
  messages += [
    {'role': 'user', 'content': user_input},
    {'role': 'assistant', 'content': response.message.content},
  ]
  print(response.message.content + '\n')

代码输出：

二、Generate —— 使用模型生成文本

1、让模型生成一个文本

        这是最普通的让模型生成一个文本的方式了。代码如下

from ollama import generate

response = generate('llama3.2', '为什么天空是蓝色的？')
print(response['response'])

代码输出：

2、让模型异步（非阻塞）生成文本

代码如下：

import asyncio

import ollama


async def main():
  client = ollama.AsyncClient()
  response = await client.generate('llama3.2', '为什么天空是蓝色的？')
  print(response['response'])


if __name__ == '__main__':
  try:
    asyncio.run(main())
  except KeyboardInterrupt:
    print('\nGoodbye!')

代码输出：

3、生成文本以流式输出

代码如下：

from ollama import generate

for part in generate('llama3.2', '为什么天空是蓝色的？', stream=True):
  print(part['response'], end='', flush=True)

代码输出：

        会像对话一样一个个来输出，自己运行一下会更有体会。

4、给出前后文，让模型填充中间的内容

代码如下：

from ollama import generate

prompt = '''def remove_non_ascii(s: str) -> str:
    """ '''

# 填充中间缺失的代码

suffix = """
    return result
"""

response = generate(
  model='codellama:7b-code',
  prompt=prompt,
  suffix=suffix,
  options={
    'num_predict': 128,
    'temperature': 0,
    'top_p': 0.9,
    'stop': ['<EOT>'],
  },
)

print(response['response'])

代码输出：

三、Tools —— 使用模型调用函数

1、简单的使用模型调用函数

代码如下：

from ollama import ChatResponse, chat


def add_two_numbers(a: int, b: int) -> int:
  """
  增加两个整数变量：
    输入：
        a (int): 第一个整数数字
        b (int): 第二个整数数字

    返回:
        int: 两个输入整数的和
  """
  # 进行类型转换是必要的，因为 return 给函数（tool）的参数并不总是完全符合格式的
  # 例如，这样可以避免处理“30加12等于多少”这个问题时，得到的结果是"3012"而不是42
  return int(a) + int(b)


def subtract_two_numbers(a: int, b: int) -> int:
  """
  将两个整数相减
  """
  # 进行类型转换是必要的，因为 return 给函数（tool）的参数并不总是完全符合格式的
  return int(a) - int(b)

# tool 可以进行自定义设置，然后给到聊天当中
subtract_two_numbers_tool = {
  'type': 'function',
  'function': {
    'name': 'subtract_two_numbers',
    'description': '将两个整数相减',
    'parameters': {
      'type': 'object',
      'required': ['a', 'b'],
      'properties': {
        'a': {'type': 'integer', 'description': '第一个数字'},
        'b': {'type': 'integer', 'description': '第二个数字'},
      },
    },
  },
}

messages = [{'role': 'user', 'content': '三加一等于多少？'}]
print('Prompt:', messages[0]['content'])

available_functions = {
  'add_two_numbers': add_two_numbers,
  'subtract_two_numbers': subtract_two_numbers,
}

# 把用户提出的问题交给模型，让模型决定使用哪个 tool 进行相应
response: ChatResponse = chat(
  'llama3.2',
  messages=messages,
  tools=[add_two_numbers, subtract_two_numbers_tool],
)

if response.message.tool_calls:
  # 响应中可能会有多个函数调用
  for tool in response.message.tool_calls:
    # 确保函数是可以被调用的
    if function_to_call := available_functions.get(tool.function.name):
      print('Calling function:', tool.function.name)
      print('Arguments:', tool.function.arguments)
      output = function_to_call(**tool.function.arguments)
      print('Function output:', output)
    else:
      print('Function', tool.function.name, '没发现该函数')

# 只需要使用函数调用的结果与模型进行聊天
if response.message.tool_calls:
  # 将函数响应添加到消息中，以供模型使用
  messages.append(response.message)
  messages.append({'role': 'tool', 'content': str(output), 'name': tool.function.name})

  # 利用函数输出从模型获取最终的响应
  final_response = chat('llama3.2', messages=messages)
  print('Final response:', final_response.message.content)
else:
  print('模型未返回任何可调用的 tool')

代码输出：

2、使用模型异步（非阻塞）调用函数

代码如下：

import asyncio

import ollama
from ollama import ChatResponse


def add_two_numbers(a: int, b: int) -> int:
  """
  增加两个整数变量：
    输入：
        a (int): 第一个整数数字
        b (int): 第二个整数数字

    返回:
        int: 两个输入整数的和
  """
  return a + b


def subtract_two_numbers(a: int, b: int) -> int:
  """
  将两个整数相减
  """
  return a - b

# tool 可以进行自定义设置，然后给到聊天当中
subtract_two_numbers_tool = {
  'type': 'function',
  'function': {
    'name': 'subtract_two_numbers',
    'description': '将两个整数相减',
    'parameters': {
      'type': 'object',
      'required': ['a', 'b'],
      'properties': {
        'a': {'type': 'integer', 'description': '第一个数字'},
        'b': {'type': 'integer', 'description': '第二个数字'},
      },
    },
  },
}

messages = [{'role': 'user', 'content': '三加一等于多少？'}]
print('Prompt:', messages[0]['content'])

available_functions = {
  'add_two_numbers': add_two_numbers,
  'subtract_two_numbers': subtract_two_numbers,
}


# 异步的把用户提出的问题交给模型，让模型决定使用哪个 tool 进行相应
async def main():
  client = ollama.AsyncClient()

  response: ChatResponse = await client.chat(
    'llama3.2',
    messages=messages,
    tools=[add_two_numbers, subtract_two_numbers_tool],
  )

  if response.message.tool_calls:
    # 响应中可能会有多个函数调用
    for tool in response.message.tool_calls:
      # 确保函数是可以被调用的
      if function_to_call := available_functions.get(tool.function.name):
        print('Calling function:', tool.function.name)
        print('Arguments:', tool.function.arguments)
        output = function_to_call(**tool.function.arguments)
        print('Function output:', output)
      else:
        print('Function', tool.function.name, '没发现该函数')

  # 只需要使用函数调用的结果与模型进行聊天
  if response.message.tool_calls:
    # 将函数响应添加到消息中，以供模型使用
    messages.append(response.message)
    messages.append({'role': 'tool', 'content': str(output), 'name': tool.function.name})

    # 利用函数输出从模型获取最终的响应
    final_response = await client.chat('llama3.2', messages=messages)
    print('Final response:', final_response.message.content)
  else:
    print('模型未返回任何可调用的 tool')


if __name__ == '__main__':
  try:
    asyncio.run(main())
  except KeyboardInterrupt:
    print('\nGoodbye!')

代码输出：

四、Images —— 使用多模态（multimodal，图像聊天）模型聊天

1、与多模态模型进行聊天

代码如下：

import base64
from ollama import chat

from pathlib import Path

# 图片的路径
path = input('Please enter the path to the image: ')

# 你可以以 base64 编码的形式传入图像，代码如下
img = base64.b64encode(Path(path).read_bytes()).decode()
# 或者用字节的形式，代码如下
# img = Path(path).read_bytes()

response = chat(
  model='llama3.2-vision',
  messages=[
    {
      'role': 'user',
      'content': '这张图片里有什么？请简要说明。',
      'images': [path],
    }
  ],
)

print(response.message.content)

代码输出：

        我们传入的图片如下

2、让多模态模型生成文本

代码如下：

import random
import sys

import httpx

from ollama import generate

latest = httpx.get('https://xkcd.com/info.0.json')
latest.raise_for_status()

if len(sys.argv) > 1:
  num = int(sys.argv[1])
else:
  num = random.randint(1, latest.json().get('num'))

comic = httpx.get(f'https://xkcd.com/{num}/info.0.json')
comic.raise_for_status()

print(f'xkcd #{comic.json().get("num")}: {comic.json().get("alt")}')
print(f'link: https://xkcd.com/{num}')
print('---')

raw = httpx.get(comic.json().get('img'))
raw.raise_for_status()

for response in generate('llava', 'explain this comic:', images=[raw.content], stream=True):
  print(response['response'], end='', flush=True)

print()

代码输出：

        代码中的 https://xkcd.com/2240/info.0.json 会返回一个 JSON ，里面包含了图片名称、地址、发布时间等的信息，如下图所示

        最后模型生成的文本如下

五、格式化输出

1、让模型格式化的输出文本

代码如下：

from pydantic import BaseModel

from ollama import chat


# 定义响应的框架（schema）
class FriendInfo(BaseModel):
  name: str
  age: int
  is_available: bool


# 定义一个包含 FriendInfo 对象的列表
class FriendList(BaseModel):
  friends: list[FriendInfo]    # [FriendInfo.name,FriendInfo.age,FriendInfo.is_available]


# schema = {'type': 'object', 'properties': {'friends': {'type': 'array', 'items': {'type': 'object', 'properties': {'name': {'type': 'string'}, 'age': {'type': 'integer'}, 'is_available': {'type': 'boolean'}}, 'required': ['name', 'age', 'is_available']}}}, 'required': ['friends']}
response = chat(
  model='llama3.2',
  messages=[{'role': 'user', 'content': '我有两个朋友。第一个是 Ollama，22岁，正忙于拯救世界；第二个是 Alonso，23 岁，想要出去玩。请以 JSON 格式返回一个朋友列表'}],
  format=FriendList.model_json_schema(),  # 用 Pydantic 来生成 schema 或者 format=schema
  options={'temperature': 0},  # 调低模型的温度参数，使响应更加具有确定性
)

# 用 Pydantic 来验证响应
friends_response = FriendList.model_validate_json(response.message.content)
print(friends_response)

代码输出：

2、让模型异步（非阻塞）的格式化输出文本

代码如下：

import asyncio

from pydantic import BaseModel

from ollama import AsyncClient


# 定义响应的框架（schema）
class FriendInfo(BaseModel):
  name: str
  age: int
  is_available: bool


# 定义一个包含 FriendInfo 对象的列表
class FriendList(BaseModel):
  friends: list[FriendInfo]


async def main():
  client = AsyncClient()
  response = await client.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': '我有两个朋友。第一个是 Ollama，22岁，正忙于拯救世界；第二个是 Alonso，23 岁，想要出去玩。请以 JSON 格式返回一个朋友列表'}],
    format=FriendList.model_json_schema(),  # 用 Pydantic 来生成框架（schema）
    options={'temperature': 0},  # 调低模型的温度参数，使响应更加具有确定性
  )

  # 用 Pydantic 来验证响应
  friends_response = FriendList.model_validate_json(response.message.content)
  print(friends_response)


if __name__ == '__main__':
  asyncio.run(main())

代码输出：

3、让模型分析图像并格式化的输出

代码如下：

from pathlib import Path
from typing import Literal

from pydantic import BaseModel

from ollama import chat


# 定义图片对象的框架（schema）
class Object(BaseModel):
  name: str
  confidence: float
  attributes: str


class ImageDescription(BaseModel):
  summary: str
  objects: list[Object]
  scene: str
  colors: list[str]
  time_of_day: Literal['早上', '下午', '晚上', '夜晚']
  setting: Literal['室内的', '室外的', '未知的']
  text_content: str | None = None


# 通过用户输入来获取图片路径
path = input('Enter the path to your image: ')
path = Path(path)

# 验证文件是否存在
if not path.exists():
  raise FileNotFoundError(f'Image not found at: {path}')

# 像普通聊天那样设置
response = chat(
  model='llama3.2-vision',
  format=ImageDescription.model_json_schema(),  # 向模型传入响应框架
  messages=[
    {
      'role': 'user',
      'content': '分析这张图片，并返回一份详细的JSON描述，内容包括物体、场景、颜色以及检测到的任何文本。如果你无法确定某些细节，则将那些字段留空。 ',
      'images': [path],
    },
  ],
  options={'temperature': 0},  # 将模型的温度参数调整为0，使响应更加具有确定性
)


# 将接收到的响应内容转换为相应的框架
image_analysis = ImageDescription.model_validate_json(response.message.content)
print(image_analysis)

代码输出：

        我们传入的图片如下

summary='This image depicts a group of soldiers in camouflage uniforms, armed with rifles and positioned behind a makeshift shelter or bunker. The scene appears to be set in a wooded area, possibly during a military operation or training exercise.' objects=[] scene='wooded area' colors=['green', 'brown'] time_of_day='夜晚' setting='未知的' text_content=''

六、List —— 列出本地模型及属性

代码如下：

from ollama import ListResponse, list

response: ListResponse = list()

for model in response.models:
  print('Name:', model.model)
  print('  Size (MB):', f'{(model.size.real / 1024 / 1024):.2f}')
  if model.details:
    print('  Format:', model.details.format)
    print('  Family:', model.details.family)
    print('  Parameter Size:', model.details.parameter_size)
    print('  Quantization Level:', model.details.quantization_level)
  print('\n')

代码输出：

七、Ps —— 显示当前正在运行的模型的信息

代码如下：

from ollama import ProcessResponse, chat, ps, pull

# 确认加载了至少一个模型
response = pull('llama3.2', stream=True)
progress_states = set()
for progress in response:
  if progress.get('status') in progress_states:
    continue
  progress_states.add(progress.get('status'))
  print(progress.get('status'))

print('\n')

print('Waiting for model to load... \n')
chat(model='llama3.2', messages=[{'role': 'user', 'content': 'Why is the sky blue?'}])


response: ProcessResponse = ps()
for model in response.models:
  print('Model: ', model.model)
  print('  Digest: ', model.digest)
  print('  Expires at: ', model.expires_at)
  print('  Size: ', model.size)
  print('  Size vram: ', model.size_vram)
  print('  Details: ', model.details)
  print('\n')

代码输出：

八、从 Ollama 官方库下载模型

代码如下：

from tqdm import tqdm

from ollama import pull

current_digest, bars = '', {}
for progress in pull('llama3.2', stream=True):
  digest = progress.get('digest', '')
  if digest != current_digest and current_digest in bars:
    bars[current_digest].close()

  if not digest:
    print(progress.get('status'))
    continue

  if digest not in bars and (total := progress.get('total')):
    bars[digest] = tqdm(total=total, desc=f'pulling {digest[7:19]}', unit='B', unit_scale=True)

  if completed := progress.get('completed'):
    bars[digest].update(completed - bars[digest].n)

  current_digest = digest

代码输出：

九、Create —— 用 Modelfile 文件创建模型

代码如下：

from ollama import Client

client = Client()
response = client.create(
  model='my-assistant',
  from_='llama3.2',
  system='你是《喜羊羊与灰太狼》里的喜羊羊。',
  stream=False,
)
print(response.status)

代码输出：

十、Embed —— 使用模型生成嵌入向量

代码如下：

from ollama import embed

response = embed(model='llama3.2', input='Hello, world!')
print(response['embeddings'])

代码输出：