Ollama Python Library: Complete API Reference 2026

# Requires Python 3.9+ — tested on 3.12
pip install ollama --upgrade

python -c "import ollama; print(ollama.__version__)"

import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user",   "content": "What is the capital of France?"},
    ],
)

print(response["message"]["content"])
# → "The capital of France is Paris."

messages = [
    {"role": "system",    "content": "..."},  # Sets model behavior
    {"role": "user",      "content": "..."},  # Human turn
    {"role": "assistant", "content": "..."},  # Prior model turn (for multi-turn)
    {"role": "tool",      "content": "..."},  # Tool call result (function calling)
]

{
    "model": "llama3.2",
    "created_at": "2026-03-12T10:00:00Z",
    "message": {
        "role": "assistant",
        "content": "The capital of France is Paris."
    },
    "done": True,
    "total_duration": 1234567890,   # nanoseconds
    "load_duration": 123456789,
    "prompt_eval_count": 18,
    "prompt_eval_duration": 456789012,
    "eval_count": 9,
    "eval_duration": 654321098
}

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Tell me a short story."}],
    stream=True,
)

for chunk in stream:
    # chunk["message"]["content"] is the new token(s) in this chunk
    print(chunk["message"]["content"], end="", flush=True)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"],
            },
        },
    }
]

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "What's the weather in Austin?"}],
    tools=tools,
)

# Model returns a tool_calls list instead of plain content
tool_calls = response["message"].get("tool_calls", [])
for call in tool_calls:
    print(call["function"]["name"])    # → "get_weather"
    print(call["function"]["arguments"])  # → {"city": "Austin"}

response = ollama.generate(
    model="llama3.2",
    prompt="The Pythagorean theorem states that",
)

print(response["response"])

{
    "model": "llama3.2",
    "created_at": "2026-03-12T10:00:00Z",
    "response": "...generated text...",
    "done": True,
    "context": [1, 2, 3, ...],   # Pass back in next call for continuity
    "total_duration": 1234567890,
    "load_duration": 123456789,
    "prompt_eval_count": 10,
    "prompt_eval_duration": 234567890,
    "eval_count": 50,
    "eval_duration": 876543210
}

import base64

with open("chart.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = ollama.generate(
    model="llava",  # or bakllava, moondream
    prompt="Describe this chart in detail.",
    images=[image_b64],
)
print(response["response"])

response = ollama.embeddings(
    model="nomic-embed-text",  # Dedicated embedding model — don't use chat models here
    prompt="The quick brown fox jumps over the lazy dog.",
)

vector = response["embedding"]
print(len(vector))  # → 768 for nomic-embed-text

texts = ["document one", "document two", "document three"]

vectors = [
    ollama.embeddings(model="nomic-embed-text", prompt=t)["embedding"]
    for t in texts
]

# Now store in a vector DB (pgvector, Chroma, Qdrant, etc.)

# Blocking pull — waits until download is complete
ollama.pull("llama3.2")

# Streaming pull — shows download progress
for progress in ollama.pull("llama3.2:70b", stream=True):
    status = progress.get("status", "")
    completed = progress.get("completed", 0)
    total = progress.get("total", 0)
    if total:
        pct = round(completed / total * 100, 1)
        print(f"{status} — {pct}%", end="\r")

# Requires: ollama.com account + `ollama.com/` prefix in model name
for progress in ollama.push("yourname/mymodel:latest", stream=True):
    print(progress.get("status", ""))

modelfile = """
FROM llama3.2
SYSTEM You are a senior Python engineer who writes concise, idiomatic code.
PARAMETER temperature 0.3
"""

for status in ollama.create(model="code-assistant", modelfile=modelfile, stream=True):
    print(status.get("status", ""))

models = ollama.list()

for m in models["models"]:
    print(m["name"], m["size"], m["modified_at"])
    # → "llama3.2:latest  2147483648  2026-03-10T..."

info = ollama.show("llama3.2")

print(info["modelfile"])   # Full Modelfile content
print(info["parameters"])  # Parameter block from Modelfile
print(info["template"])    # Prompt template
print(info["details"])     # Family, quantization, parameter count

# Useful before destructive Modelfile edits
ollama.copy("llama3.2", "llama3.2-backup")

ollama.delete("llama3.2-backup")

from ollama import Client

client = Client(
    host="http://192.168.1.50:11434",  # Remote Ollama server on your LAN
    headers={"Authorization": "Bearer my-token"},  # If behind a proxy
)

response = client.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Hello"}],
)

import asyncio
from ollama import AsyncClient

async def main():
    client = AsyncClient()

    # Async chat
    response = await client.chat(
        model="llama3.2",
        messages=[{"role": "user", "content": "What is 12 * 12?"}],
    )
    print(response["message"]["content"])

    # Async streaming
    async for chunk in await client.chat(
        model="llama3.2",
        messages=[{"role": "user", "content": "Count to 5."}],
        stream=True,
    ):
        print(chunk["message"]["content"], end="", flush=True)

    # Async batch embeddings — parallelized
    texts = ["doc one", "doc two", "doc three"]
    tasks = [
        client.embeddings(model="nomic-embed-text", prompt=t)
        for t in texts
    ]
    results = await asyncio.gather(*tasks)
    vectors = [r["embedding"] for r in results]
    print(f"Got {len(vectors)} vectors")

asyncio.run(main())

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from ollama import AsyncClient

app = FastAPI()
client = AsyncClient()

@app.post("/chat")
async def chat(prompt: str):
    async def token_stream():
        async for chunk in await client.chat(
            model="llama3.2",
            messages=[{"role": "user", "content": prompt}],
            stream=True,
        ):
            yield chunk["message"]["content"]

    return StreamingResponse(token_stream(), media_type="text/plain")

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # Required by the SDK — value is ignored by Ollama
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Hello"}],
)

print(response.choices[0].message.content)

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Write a haiku."}],
    options={
        "temperature": 0.9,    # Higher creativity for creative writing
        "num_ctx": 4096,       # Enough context for long conversations
        "seed": 42,            # Reproducible output for testing
    },
)

import ollama

try:
    response = ollama.chat(
        model="llama3.2",
        messages=[{"role": "user", "content": "Hello"}],
    )
except ollama.ResponseError as e:
    # e.status_code: HTTP status (404, 500, etc.)
    # e.error: error message string from Ollama
    print(f"Ollama error {e.status_code}: {e.error}")
except Exception as e:
    # ConnectionRefusedError if Ollama is not running
    print(f"Connection error: {e}")

python - <<'EOF'
import ollama

# 1. List local models
models = ollama.list()
print("Models:", [m["name"] for m in models["models"]])

# 2. Chat
r = ollama.chat("llama3.2", messages=[{"role":"user","content":"Say OK"}])
print("Chat:", r["message"]["content"])

# 3. Embeddings
e = ollama.embeddings("nomic-embed-text", prompt="test")
print("Embedding dims:", len(e["embedding"]))
EOF