Ollama Free code examples in C#, Python, Java and JavaScript

Pull a model once and it is cached on disk. gpt-oss:20b wants about 16GB of RAM; qwen3:8b runs comfortably on a laptop.

# https://ollama.com/download, then:
ollama pull gpt-oss:20b
ollama pull qwen3:8b

ollama list
ollama run qwen3:8b "Explain a database index in two sentences."

pip install openai

THIS IS THE WHOLE MIGRATION. Same package, same method, same response shape — only base_url changed. The key is required by the client and ignored by the server.

from openai import OpenAI

# Required by the client, ignored by Ollama. Not a real credential,
# so nothing valuable ends up in a config pointing at localhost.
PLACEHOLDER_KEY = "ollama"

client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key=PLACEHOLDER_KEY,
)

response = client.chat.completions.create(
    model="gpt-oss:20b",
    messages=[{"role": "user", "content": "Explain a database index."}],
)

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

Because the API is the same, the choice is a factory rather than a fork through the codebase. This is the shape worth writing on day one — it costs nothing and it is what makes a local model a real option later.

import os

def build_client():
    if os.environ.get("USE_LOCAL"):
        # Anything on your machine, at no cost per token.
        return OpenAI(
            base_url="http://localhost:11434/v1/",
            api_key=PLACEHOLDER_KEY,
        ), "gpt-oss:20b"

    if os.environ.get("OLLAMA_API_KEY"):
        # Ollama's own hosted service — same API, bigger machines.
        return OpenAI(
            base_url="https://ollama.com/v1",
            api_key=os.environ["OLLAMA_API_KEY"],
        ), "gpt-oss:120b"

    return OpenAI(), "gpt-5.4-mini"

client, model = build_client()

Not every local model supports tool calling — check the model card first. When it does, the request and response shapes are identical to OpenAI's, so the calling code does not change.

tools = [{
    "type": "function",
    "function": {
        "name": "get_stock",
        "description": "Get the stock level for a product code.",
        "parameters": {
            "type": "object",
            "properties": {"code": {"type": "string"}},
            "required": ["code"],
        },
    },
}]

response = client.chat.completions.create(
    model="gpt-oss:20b",
    messages=[{"role": "user", "content": "How many X-17 are in stock?"}],
    tools=tools,
)

call = response.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)

A model that does not fit in RAM is swapped to disk and becomes unusably slow rather than failing. Check before you deploy, not after the first complaint.

# What is loaded right now, and how much it is using.
ollama ps

# Everything available locally, with sizes.
ollama list

# Rough guide: the file size is the floor for RAM, plus context.
#   qwen3:8b      ~5GB   comfortable on a 16GB laptop
#   gpt-oss:20b   ~14GB  wants 32GB to be pleasant
#   gemma4:31b    ~20GB  a workstation, not a laptop
#
# Over the limit it does not error — it swaps, and a reply that took
# two seconds takes two minutes.

The official openai-java client takes a base URL. No Ollama-specific dependency exists or is needed.

ollama pull gpt-oss:20b

# Gradle
implementation("com.openai:openai-java:4.42.0")

baseUrl plus a placeholder key. Everything after this line is the same code you would write against OpenAI.

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class Local {
    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.builder()
            .baseUrl("http://localhost:11434/v1/")
            // Required by the client, ignored by Ollama.
            .apiKey("ollama")
            .build();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .model("gpt-oss:20b")
            .addUserMessage("Explain a database index in two sentences.")
            .build();

        client.chat().completions().create(params).choices()
            .forEach(choice -> System.out.println(choice.message().content().orElse("")));
    }
}

The switch lives in one method. Everything downstream holds an OpenAIClient and does not care which machine answers it.

static OpenAIClient buildClient() {
    if (System.getenv("USE_LOCAL") != null) {
        return OpenAIOkHttpClient.builder()
            .baseUrl("http://localhost:11434/v1/")
            .apiKey("ollama")
            .build();
    }

    String hosted = System.getenv("OLLAMA_API_KEY");
    if (hosted != null) {
        return OpenAIOkHttpClient.builder()
            .baseUrl("https://ollama.com/v1")
            .apiKey(hosted)
            .build();
    }

    // Reads OPENAI_API_KEY.
    return OpenAIOkHttpClient.fromEnv();
}

The first request after a pull loads gigabytes from disk. A default timeout plus automatic retries turns that into several concurrent loads on the same machine, which is slower than waiting.

import java.time.Duration;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("http://localhost:11434/v1/")
    .apiKey("ollama")
    .timeout(Duration.ofMinutes(5))
    // A cold load is not transient. Retrying it makes it worse.
    .maxRetries(0)
    .build();

The official OpenAI package works unchanged. Nothing Ollama-specific is installed on the client side.

ollama pull gpt-oss:20b
npm install openai

Same package, same call, same response. The base URL is the only difference between this and a hosted model.

import OpenAI from "openai";

// Required by the client, ignored by Ollama.
const placeholderKey = "ollama";

const client = new OpenAI({
  baseURL: "http://localhost:11434/v1/",
  apiKey: placeholderKey,
});

const response = await client.chat.completions.create({
  model: "gpt-oss:20b",
  messages: [{ role: "user", content: "Explain a database index." }],
});

console.log(response.choices[0].message.content);

A factory rather than a branch in every call site. Writing it early is what keeps a local model from being a rewrite later.

function buildClient() {
  if (process.env.USE_LOCAL) {
    return [
      new OpenAI({ baseURL: "http://localhost:11434/v1/", apiKey: placeholderKey }),
      "gpt-oss:20b",
    ];
  }

  if (process.env.OLLAMA_API_KEY) {
    return [
      new OpenAI({
        baseURL: "https://ollama.com/v1",
        apiKey: process.env.OLLAMA_API_KEY,
      }),
      "gpt-oss:120b",
    ];
  }

  return [new OpenAI(), "gpt-5.4-mini"];
}

const [client, model] = buildClient();

The first request after a pull loads the model into memory, which can take many seconds. Streaming makes that visible; a keep-alive stops it happening on every request.

const started = Date.now();
let firstTokenAt = null;

const stream = await client.chat.completions.create({
  model: "gpt-oss:20b",
  messages: [{ role: "user", content: "Explain B-trees in 200 words." }],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) {
    firstTokenAt ??= Date.now() - started;
    process.stdout.write(delta);
  }
}

// A large first number is the model loading, not the model thinking.
// `ollama run <model> --keepalive 60m` holds it in memory.
console.log(`\nfirst token after ${firstTokenAt}ms`);