AI Reasoning Models: o1, o3, DeepSeek R1, and How to Use Them

from openai import OpenAI

client = OpenAI()

# o3-mini: good balance of capability and cost
response = client.chat.completions.create(
    model="o3-mini",
    messages=[
        {
            "role": "user",
            "content": """
            A train leaves Chicago at 9am traveling at 60mph toward New York (790 miles away).
            Another train leaves New York at 11am traveling at 80mph toward Chicago.
            At what time do they meet, and how far from Chicago?
            Show your work.
            """
        }
    ],
    # reasoning_effort controls how much the model thinks
    # "low" = faster/cheaper, "high" = slower/better
    reasoning_effort="medium",
)

print(response.choices[0].message.content)
# The model will show step-by-step work and arrive at the correct answer

# o1 excels at finding subtle bugs
response = client.chat.completions.create(
    model="o1",
    messages=[
        {
            "role": "user",
            "content": """
            This Python function is supposed to find all prime numbers up to n,
            but it's returning wrong results for some inputs. Find and fix the bug:

            def sieve_of_eratosthenes(n):
                primes = [True] * (n + 1)
                primes[0] = primes[1] = False
                for i in range(2, int(n**0.5)):  # bug is here
                    if primes[i]:
                        for j in range(i*i, n+1, i):
                            primes[j] = False
                return [i for i in range(n+1) if primes[i]]

            print(sieve_of_eratosthenes(10))  # returns [2, 3, 5, 7] ✓
            print(sieve_of_eratosthenes(25))  # should include 23 but doesn't
            """
        }
    ],
)
# o1 will identify: range(2, int(n**0.5)) should be range(2, int(n**0.5) + 1)
# because int(25**0.5) = 5, but we need to check 5 itself

import time

problem = """
Prove that for any positive integer n, the sum of the first n odd numbers equals n².
Then write a Python function that verifies this for n = 1 to 100.
"""

# GPT-4o: fast but may make errors on the proof
start = time.time()
gpt4o_response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": problem}]
)
print(f"GPT-4o: {time.time()-start:.1f}s")

# o1: slower but more reliable on mathematical reasoning
start = time.time()
o1_response = client.chat.completions.create(
    model="o1-mini",
    messages=[{"role": "user", "content": problem}]
)
print(f"o1-mini: {time.time()-start:.1f}s")

# Typical results:
# GPT-4o: 2.1s — may have gaps in the proof
# o1-mini: 15.3s — rigorous proof with verification

from openai import OpenAI  # DeepSeek uses OpenAI-compatible API

client = OpenAI(
    api_key="your-deepseek-api-key",
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-reasoner",  # R1 model
    messages=[
        {
            "role": "user",
            "content": "What is the time complexity of merge sort? Explain why."
        }
    ],
)

# DeepSeek R1 shows its reasoning trace
print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pull DeepSeek R1 (7B fits on consumer GPU)
ollama pull deepseek-r1:7b

# Run
ollama run deepseek-r1:7b "Solve: if 3x + 7 = 22, what is x?"

# Use via Python
import ollama

response = ollama.chat(
    model='deepseek-r1:7b',
    messages=[{
        'role': 'user',
        'content': 'Write a recursive function to compute Fibonacci numbers, then optimize it with memoization.'
    }]
)

print(response['message']['content'])
# Shows <think>...</think> reasoning trace, then the answer

# BAD: reasoning models don't need "think step by step"
# They already do this internally
response = client.chat.completions.create(
    model="o1-mini",
    messages=[{
        "role": "user",
        "content": "Think step by step and carefully reason through this problem..."  # unnecessary
    }]
)

# GOOD: just state the problem clearly
response = client.chat.completions.create(
    model="o1-mini",
    messages=[{
        "role": "user",
        "content": "Find all integer solutions to x² - 5x + 6 = 0"
    }]
)

# BAD: telling the model HOW to think
"First, identify the variables. Then, set up equations. Then solve..."

# GOOD: give context and let the model reason
"I'm debugging a race condition in a multi-threaded Python application. Here's the code: [code]. The issue occurs intermittently under high load."

# Use reasoning models to verify outputs from faster models
def verify_with_reasoning_model(code: str, test_cases: list) -> dict:
    """Use o1 to verify code correctness."""

    test_str = "\n".join([f"Input: {t['input']}, Expected: {t['expected']}" for t in test_cases])

    response = client.chat.completions.create(
        model="o1-mini",
        messages=[{
            "role": "user",
            "content": f"""
            Verify this code is correct for all test cases.
            If there are bugs, identify them precisely.

            Code:
            {code}

            Test cases:
            {test_str}
            """
        }]
    )

    return {"verification": response.choices[0].message.content}

# Route queries to the right model based on complexity

def smart_route(question: str) -> str:
    """Use cheap model for simple questions, reasoning model for hard ones."""

    # Quick complexity check with cheap model
    classifier = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{
            "role": "user",
            "content": f"Is this question complex (requires multi-step reasoning, math, or debugging)? Answer only YES or NO.\n\nQuestion: {question}"
        }],
        max_tokens=5,
    )

    is_complex = "YES" in classifier.choices[0].message.content.upper()

    if is_complex:
        # Use reasoning model for hard questions
        response = client.chat.completions.create(
            model="o3-mini",
            messages=[{"role": "user", "content": question}],
            reasoning_effort="medium",
        )
    else:
        # Use fast model for simple questions
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": question}],
        )

    return response.choices[0].message.content

# Examples:
print(smart_route("What is the capital of France?"))  # → gpt-4o-mini
print(smart_route("Prove the Pythagorean theorem"))   # → o3-mini