Ollama Cheat Sheet: Local LLMs, Models, API & Integration (2026)

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.3:8b",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "What is recursion?" }
  ],
  "stream": false
}'

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.3:8b",
  "prompt": "Write a Python function to reverse a string.",
  "stream": false
}'

curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "The quick brown fox jumps over the lazy dog"
}'

# Copy model
curl http://localhost:11434/api/create -d '{"name": "my-llama", "path": "llama3.3:8b"}'

# Generate a raw model (no prompt)
curl http://localhost:11434/api/generate -d '{"model": "llama3.3:8b", "raw": true}'

# Show model info
curl http://localhost:11434/api/show -d '{"name": "llama3.3:8b"}'

pip install ollama

import ollama

# Chat
response = ollama.chat(
    model='llama3.3:8b',
    messages=[
        {'role': 'system', 'content': 'You are a code reviewer.'},
        {'role': 'user', 'content': 'Review this function:\ndef add(a, b): return a + b'},
    ],
    options={'temperature': 0.3}
)
print(response['message']['content'])

# Generate
response = ollama.generate(
    model='deepseek-r1:8b',
    prompt='Explain Docker containers in one sentence.',
    stream=False
)
print(response['response'])

# Embeddings
embedding = ollama.embeddings(
    model='nomic-embed-text',
    prompt='local vector search example'
)
print(f"Embedding size: {len(embedding['embedding'])}")

# List models
models = ollama.list()
for m in models['models']:
    print(f"{m['name']} — {m['size'] // (1024**3)} GB")

# Pull a model
ollama.pull('qwen3:8b')

# Streaming
for chunk in ollama.chat(model='llama3.3:8b', messages=[{'role': 'user', 'content': 'Hello'}]):
    print(chunk['message']['content'], end='', flush=True)

npm install ollama

import Ollama from 'ollama';

const client = new Ollama();

// Chat
const response = await client.chat({
  model: 'llama3.3:8b',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What are the best practices for REST APIs?' },
  ],
  options: { temperature: 0.5, num_predict: 512 },
});

console.log(response.message.content);

// Streaming
const stream = await client.chat({
  model: 'llama3.3:8b',
  stream: true,
  messages: [{ role: 'user', content: 'Write a bash script to backup a directory.' }],
});

for await (const chunk of stream) {
  process.stdout.write(chunk.message.content);
}

// Generate embeddings
const embedding = await client.embeddings({
  model: 'nomic-embed-text',
  prompt: 'text to embed for vector search',
});
console.log(`Dimension: ${embedding.embedding.length}`);

# Modelfile
FROM llama3.3:8b

# System prompt — the model's behavior
SYSTEM """
You are a senior backend engineer specializing in Python and PostgreSQL.
When answering questions:
- Provide working code with imports
- Include error handling
- Mention performance considerations
- Use type hints in Python examples
"""

# Parameters
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 8192
PARAMETER num_gpu 1

ollama create backend-expert -f Modelfile
ollama run backend-expert "How do I implement connection pooling in asyncpg?"

nvidia-smi
ollama list  # Check if models are using GPU

# Ollama auto-uses Metal on Apple Silicon
# Check VRAM usage
Activity Monitor → GPU tab

# Force CPU-only (if you have issues)
OLLAMA_DEBUG=1 ollama serve

# Use specific GPU
CUDA_VISIBLE_DEVICES=0 ollama serve

# Use all available
CUDA_VISIBLE_DEVICES=0,1 ollama serve

# Check model memory usage
ollama ps

# Stop a model to free memory
ollama stop llama3.3:8b

# Run a specific size on limited VRAM
ollama run llama3.3:8b  # 8B fits in ~8GB VRAM
ollama run gemma3:4b     # 4B fits in ~4GB VRAM
ollama run phi4:3.8b     # 3.8B fits in ~4GB VRAM

import ollama

def embed_chunks(chunks: list[str]) -> list[list[float]]:
    """Embed text chunks for vector search."""
    return [ollama.embeddings(model='nomic-embed-text', prompt=c)['embedding'] for c in chunks]

def cosine_similarity(a: list[float], b: list[float]) -> float:
    import math
    dot = sum(x*y for x,y in zip(a,b))
    norm_a = math.sqrt(sum(x*x for x in a))
    norm_b = math.sqrt(sum(x*x for x in b))
    return dot / (norm_a * norm_b)

def retrieve(query: str, chunks: list[str], embeddings: list[list[float]], top_k: int = 5):
    """Find top-k chunks most similar to query."""
    query_emb = ollama.embeddings(model='nomic-embed-text', prompt=query)['embedding']
    scored = sorted(zip(chunks, embeddings, range(len(chunks))),
                    key=lambda x: cosine_similarity(query_emb, x[1]), reverse=True)
    return [c[0] for c in scored[:top_k]]

def rag_query(query: str, chunks: list[str], embeddings: list[list[float]]):
    """RAG query: retrieve context + generate answer."""
    context = '\n\n'.join(retrieve(query, chunks, embeddings))
    prompt = f"""Context:\n{context}\n\nQuestion: {query}\n\nAnswer based on the context above:"""
    response = ollama.chat(model='llama3.3:8b', messages=[{'role': 'user', 'content': prompt}])
    return response['message']['content']

import express from 'express';
import Ollama from 'ollama';

const app = express();
app.use(express.json());

app.post('/api/chat', async (req, res) => {
  const { prompt, model = 'llama3.3:8b' } = req.body;
  const stream = await ollama.chat({ model, stream: true, messages: [{ role: 'user', content: prompt }] });
  res.setHeader('Content-Type', 'text/event-stream');
  for await (const chunk of stream) {
    res.write(`data: ${JSON.stringify(chunk)}\n\n`);
  }
  res.end();
});