Tokenization — How LLMs See Text

Text in, numbers out — every character costs money

Input:  "Understanding AI agents is essential"
Tokens: ["Under", "standing", " AI", " agents", " is", " essential"]
IDs:    [16, 8714, 15592, 12875, 374, 7718]

# Count tokens with tiktoken (OpenAI tokenizer)
import tiktoken
enc = tiktoken.encoding_for_model("gpt-4o")
tokens = enc.encode("Understanding AI agents is essential")
print(f"Token count: {len(tokens)}")  # → 5-6 tokens
print(f"Tokens: {[enc.decode([t]) for t in tokens]}")

• Token count matters: Cost (pay per token), Context window (max tokens per call), Speed (more tokens = slower)

Step 1 — API Connection (Concept)

How to call a cloud LLM from your script

1. Get an API key from a provider (e.g. Google AI Studio — free tier available)

2. Store the key in an environment variable (never hardcode it!)

3. Visit Google Gemini Model Library (https://ai.google.dev/gemini-api/docs/models)

4. Find a proper model name and store the name also

3. Use a client library to send prompts and read responses

# .env file (add to .gitignore!)
GOOGLE_API_KEY=your_api_key_here
GEMINI_MODEL=gemini-3.1-flash-lite-preview

`bash

pip install google-generativeai python-dotenv

`

Step 1a — Google Gemini API (Python)

Call Google's LLM from your script

import os
from dotenv import load_dotenv
import google.generativeai as genai

# Load API key from .env
load_dotenv()
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

# Create model and send a prompt
model = genai.GenerativeModel(os.getenv("GEMINI_MODEL"))
response = model.generate_content(
    "Explain what a Transformer is in 3 sentences."
)
print(response.text)

Step 1b — OpenAI-Compatible API (Python)

One client library, multiple providers

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

# Works with OpenAI, and also with Ollama (change base_url)
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is a Transformer in AI?"}
    ]
)
print(response.choices[0].message.content)

pip install openai python-dotenv

Step 2 — Setting up Ollama

Run LLMs on your own machine

1. Install: Download and install from [ollama.com](https://ollama.com) (Windows / macOS / Linux)

2. Pull a model: e.g. ollama pull qwen3.5:0.8b

3. Run: Ollama runs as a local server on port 11434

4. Use in code: Point your OpenAI client to http://localhost:11434/v1

Quick Reference — Ollama CLI

Essential commands for local models

ollama list              # List installed models
ollama pull qwen3.5:0.8b     # Download a model (size depends on quantization)
ollama pull mistral      # Another popular model (~4.1 GB)
ollama run qwen3.5:0.8b      # Interactive chat in terminal
ollama serve             # Start server (usually auto-starts)
ollama rm qwen3.5:0.8b       # Remove a model to free disk space

Step 3 — Call Ollama from Python

Same OpenAI client, different endpoint

from openai import OpenAI

# Point to local Ollama server (no API key needed!)
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # required by client, but not checked
)

response = client.chat.completions.create(
    model="qwen3.5:0.8b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is a Transformer in AI?"}
    ]
)
print(response.choices[0].message.content)

Unified Code — One Function, Two Backends

Switch between cloud and local with one config change

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

def create_client(backend="cloud"):
    if backend == "ollama":
        return OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
    else:
        return OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def chat(prompt, backend="cloud", model=None):
    client = create_client(backend)
    if model is None:
        model = "qwen3.5:0.8b" if backend == "ollama" else "gpt-4o-mini"
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# Usage
print(chat("Hello!", backend="cloud"))
print(chat("Hello!", backend="ollama"))