Ollama — Run LLMs Locally on Mac, Linux and Windows 2026

# Option 1: Homebrew
brew install ollama
 
# Option 2: Direct download
curl -fsSL https://ollama.com/install.sh | sh
 
# Start the Ollama server
ollama serve

curl -fsSL https://ollama.com/install.sh | sh
 
# Enable as a system service
sudo systemctl enable ollama
sudo systemctl start ollama

# Pull a model (downloads and caches locally)
ollama pull llama3          # Meta Llama 3 8B — best general-purpose
ollama pull mistral         # Mistral 7B — fast, high quality
ollama pull phi3            # Microsoft Phi-3 Mini — ultra-compact
ollama pull gemma2          # Google Gemma 2 9B — strong reasoning
ollama pull qwen2           # Alibaba Qwen 2 — multilingual
ollama pull codellama       # Meta Code Llama — code generation
ollama pull deepseek-coder  # DeepSeek Coder — code specialist
 
# List locally cached models
ollama list
 
# Show model metadata and architecture
ollama show llama3
 
# Remove a model to reclaim disk space
ollama rm mistral
 
# Pull a specific quantization variant
ollama pull llama3:8b-instruct-q4_K_M   # 4-bit quantized, ~4.7GB
ollama pull llama3:70b-instruct-q4_K_M  # 70B quantized, ~40GB

# Interactive REPL
ollama run llama3
 
# Single-shot prompt from command line
ollama run mistral "Explain the difference between TCP and UDP in two sentences."
 
# Pipe text in from stdin
echo "Summarize this: $(cat article.txt)" | ollama run llama3
 
# Run with custom parameters
ollama run mistral --verbose "Write a haiku about Python programming"

pip install ollama

import ollama
 
# Simple generation
response = ollama.generate(
    model="llama3",
    prompt="What is the difference between a list and a tuple in Python?",
)
print(response["response"])

# Chat with message history
messages = [
    {"role": "system", "content": "You are a senior Python engineer."},
    {"role": "user", "content": "How do I implement a context manager?"},
]
 
response = ollama.chat(model="llama3", messages=messages)
print(response["message"]["content"])

import ollama
 
def stream_response(prompt: str, model: str = "llama3") -> str:
    """Stream tokens to stdout and return full response."""
    full_response = ""
    stream = ollama.generate(model=model, prompt=prompt, stream=True)
    for chunk in stream:
        token = chunk["response"]
        print(token, end="", flush=True)
        full_response += token
    print()
    return full_response
 
stream_response("Write a Python decorator that logs function execution time.")

import ollama
 
class LocalChatBot:
    def __init__(self, model: str = "llama3", system_prompt: str = "You are a helpful assistant."):
        self.model = model
        self.messages = [{"role": "system", "content": system_prompt}]
 
    def chat(self, user_input: str) -> str:
        self.messages.append({"role": "user", "content": user_input})
 
        response = ollama.chat(
            model=self.model,
            messages=self.messages,
            options={"temperature": 0.7, "num_predict": 512},
        )
 
        assistant_content = response["message"]["content"]
        self.messages.append({"role": "assistant", "content": assistant_content})
        return assistant_content
 
    def reset(self):
        self.messages = [self.messages[0]]  # Keep system prompt
 
# Usage
bot = LocalChatBot(model="llama3", system_prompt="You are a Python tutor.")
print(bot.chat("What is a generator?"))
print(bot.chat("Show me a practical example."))
print(bot.chat("How does it compare to returning a list?"))

pip install langchain langchain-community langchain-ollama

from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
 
# LLM
llm = OllamaLLM(model="llama3", base_url="http://localhost:11434")
 
# Simple chain
prompt = ChatPromptTemplate.from_template(
    "Explain {concept} to a {audience} in 3 bullet points."
)
 
chain = prompt | llm | StrOutputParser()
 
result = chain.invoke({"concept": "neural networks", "audience": "high school student"})
print(result)

# Local RAG with Ollama embeddings
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document
 
embeddings = OllamaEmbeddings(model="nomic-embed-text")
 
docs = [
    Document(page_content="Ollama runs LLMs locally on consumer hardware."),
    Document(page_content="LangChain provides composable AI application primitives."),
    Document(page_content="RAG combines retrieval with generation for grounded answers."),
]
 
vectorstore = Chroma.from_documents(docs, embedding=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})
 
from langchain.chains import RetrievalQA
qa = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)
answer = qa.run("What is Ollama used for?")
print(answer)

cat > Modelfile << 'EOF'
FROM llama3
 
SYSTEM You are an expert Python code reviewer. Review code for correctness, performance, and style. Be concise and specific.
 
PARAMETER temperature 0.3
PARAMETER num_predict 1024
PARAMETER repeat_penalty 1.1
EOF
 
ollama create py-reviewer -f Modelfile
ollama run py-reviewer "Review this: def fib(n): return fib(n-1)+fib(n-2) if n>1 else n"