M28: Open Source Models — Running Agents Without an API Key

# pip install anthropic openai python-dotenv
import os
import anthropic
import openai
from dotenv import load_dotenv

load_dotenv()

PROMPT = "Explain what an LLM is in one sentence."

# ── CHUNK 1: Claude (Anthropic SDK) ─────────────────────────────────────────
# WHAT: Create the Anthropic client and call claude-sonnet-4-6.
# WHY:  This is the pattern you've used throughout the course.
# GOTCHA: ANTHROPIC_API_KEY must be set — client reads it from the environment.
claude_client = anthropic.Anthropic()

claude_response = claude_client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=256,          # required by Anthropic — no default
    system="You are a helpful assistant.",   # top-level field in Anthropic API
    messages=[{"role": "user", "content": PROMPT}]
)
claude_text = claude_response.content[0].text  # Anthropic response path

# ── CHUNK 2: Mistral via Ollama (OpenAI SDK) ─────────────────────────────────
# WHAT: Create an OpenAI client but point its base_url at Ollama's local server.
# WHY:  Ollama implements the OpenAI Chat Completions schema exactly.
#       The openai package doesn't care if it's talking to OpenAI or Ollama —
#       it just sends HTTP to whatever base_url you give it.
# GOTCHA: api_key="ollama" is a dummy value — Ollama ignores the key,
#         but the SDK requires the field to be non-empty.
ollama_client = openai.OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"         # dummy — Ollama doesn't authenticate
)

ollama_response = ollama_client.chat.completions.create(
    model="mistral",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},  # system is a message here
        {"role": "user", "content": PROMPT}
    ]
    # max_tokens is optional in OpenAI schema — omitting it uses model's default
)
ollama_text = ollama_response.choices[0].message.content  # OpenAI response path

# ── CHUNK 3: Print results side by side ────────────────────────────────────
print(f"Claude:  {claude_text}")
print(f"Mistral: {ollama_text}")

# pip install litellm python-dotenv
import litellm
from dotenv import load_dotenv

load_dotenv()

# ── CHUNK 1: The provider-agnostic call ──────────────────────────────────────
# WHAT: litellm.completion() has the same signature regardless of provider.
# WHY:  LiteLLM translates your call to each provider's native format,
#       then translates the response back to a unified OpenAI-shaped response.
# GOTCHA: The model string encodes the provider: "ollama/mistral", not "mistral".
#         For Claude: just "claude-sonnet-4-6" (LiteLLM auto-detects Anthropic).

MESSAGES = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain what an LLM is in one sentence."}
]

# Call Claude
claude_resp = litellm.completion(model="claude-sonnet-4-6", messages=MESSAGES)

# Call Mistral via Ollama — one string change
mistral_resp = litellm.completion(model="ollama/mistral", messages=MESSAGES)

# Call Mistral via Groq (cloud, faster) — another string change
# groq_resp = litellm.completion(model="groq/mistral-saba-v1", messages=MESSAGES)

# ── CHUNK 2: Response format is unified ─────────────────────────────────────
# WHAT: LiteLLM normalizes every provider's response to OpenAI's shape.
# WHY:  You always extract text the same way — no per-provider conditionals.
for label, resp in [("Claude", claude_resp), ("Mistral (Ollama)", mistral_resp)]:
    text = resp.choices[0].message.content   # same path for every provider
    tokens = resp.usage.total_tokens
    print(f"{label}: {text}")
    print(f"  Tokens used: {tokens}\n")

# provider_agnostic_chat.py
# Usage:  python provider_agnostic_chat.py --provider claude
#         python provider_agnostic_chat.py --provider mistral
#         python provider_agnostic_chat.py --provider groq
# pip install anthropic openai litellm python-dotenv

import argparse
import anthropic
import openai
from dotenv import load_dotenv

load_dotenv()

# ── CHUNK 1: Provider configuration ─────────────────────────────────────────
# WHAT: Map provider name to (client, model_id, response_extractor).
# WHY:  All provider-specific logic lives here — the rest of the code
#       never branches on provider.
# GOTCHA: Groq requires GROQ_API_KEY in your environment.
PROVIDERS = {
    "claude": {
        "sdk": "anthropic",
        "model": "claude-sonnet-4-6",
    },
    "mistral": {
        "sdk": "openai_compat",
        "base_url": "http://localhost:11434/v1",
        "api_key": "ollama",
        "model": "mistral",
    },
    "groq": {
        "sdk": "openai_compat",
        "base_url": "https://api.groq.com/openai/v1",
        "api_key_env": "GROQ_API_KEY",
        "model": "llama3-8b-8192",
    }
}

def build_client(provider_name: str):
    import os
    cfg = PROVIDERS[provider_name]
    if cfg["sdk"] == "anthropic":
        return ("anthropic", anthropic.Anthropic(), cfg["model"])
    else:
        key = cfg.get("api_key") or os.environ[cfg["api_key_env"]]
        client = openai.OpenAI(base_url=cfg["base_url"], api_key=key)
        return ("openai_compat", client, cfg["model"])

# ── CHUNK 2: The unified chat function ──────────────────────────────────────
# WHAT: Single function that calls whichever provider was selected.
# WHY:  Branching once here means zero branching in the main loop.
# GOTCHA: Anthropic requires system as top-level; OpenAI compat uses a message.
def chat(sdk_type, client, model, messages, system="You are a helpful assistant."):
    try:
        if sdk_type == "anthropic":
            resp = client.messages.create(
                model=model, max_tokens=1024,
                system=system, messages=messages
            )
            return resp.content[0].text
        else:
            full_messages = [{"role": "system", "content": system}] + messages
            resp = client.chat.completions.create(model=model, messages=full_messages)
            return resp.choices[0].message.content
    except openai.APIConnectionError:
        return "[Error: Cannot reach Ollama. Is 'ollama serve' running?]"
    except Exception as e:
        return f"[Error: {e}]"

# ── CHUNK 3: The conversation loop ──────────────────────────────────────────
# WHAT: Standard multi-turn loop — accumulate messages, call, append reply.
# WHY:  This is identical to M01 Step 5. Nothing changes when you swap providers.
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--provider", choices=["claude","mistral","groq"], default="claude")
    args = parser.parse_args()

    sdk_type, client, model = build_client(args.provider)
    print(f"\nChatting with {args.provider} ({model}). Type 'quit' to exit.\n")

    conversation = []
    while True:
        user_input = input("You: ").strip()
        if user_input.lower() in ("quit", "exit", "q"):
            break
        if not user_input:
            continue
        conversation.append({"role": "user", "content": user_input})
        reply = chat(sdk_type, client, model, conversation)
        conversation.append({"role": "assistant", "content": reply})
        print(f"\n{args.provider.capitalize()}: {reply}\n")

if __name__ == "__main__":
    main()

# ollama_hello.py
import openai

# Ollama runs on localhost:11434 and speaks the OpenAI Chat Completions schema.
# api_key="ollama" is a dummy value — Ollama doesn't authenticate, but the SDK requires the field.
client = openai.OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

try:
    response = client.chat.completions.create(
        model="mistral",
        messages=[
            {"role": "user", "content": "Explain what a language model is in one sentence."}
        ]
    )
    print("Mistral says:", response.choices[0].message.content)
    print("Tokens used:", response.usage.total_tokens)
except openai.APIConnectionError:
    print("ERROR: Cannot reach Ollama. Make sure 'ollama serve' is running in another terminal.")
except Exception as e:
    print(f"ERROR: {e}")

# litellm_swap.py
import litellm
from dotenv import load_dotenv

load_dotenv()

PROMPT = "What are three real-world use cases for AI agents in healthcare?"

PROVIDERS = [
    ("Claude Sonnet", "claude-sonnet-4-6"),
    ("Mistral 7B (Ollama)", "ollama/mistral"),
]

for label, model in PROVIDERS:
    print(f"\n{'='*50}")
    print(f"  {label}")
    print(f"{'='*50}")
    try:
        resp = litellm.completion(
            model=model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant. Be concise."},
                {"role": "user", "content": PROMPT}
            ],
            max_tokens=300
        )
        print(resp.choices[0].message.content)
        usage = resp.usage
        print(f"\n[Tokens: {usage.total_tokens} total ({usage.prompt_tokens} in / {usage.completion_tokens} out)]")
    except Exception as e:
        print(f"[Error calling {label}: {e}]")