1from openai import OpenAI
2
3client = OpenAI(base_url="https://<app>.modal.run/v1", api_key="YOUR_KEY")
4
5# Single image via URL
6response = client.chat.completions.create(
7    model="gemma-4-26b-a4b",
8    messages=[{
9        "role": "user",
10        "content": [
11            {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}},
12            {"type": "text", "text": "What's in this image?"},
13        ],
14    }],
15    max_tokens=512,
16)
17print(response.choices[0].message.content)

1import base64
2
3# Base64 encoding (recommended for reliability)
4with open("photo.jpg", "rb") as f:
5    b64 = base64.b64encode(f.read()).decode()
6
7response = client.chat.completions.create(
8    model="gemma-4-26b-a4b",
9    messages=[{
10        "role": "user",
11        "content": [
12            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
13            {"type": "text", "text": "Describe this image in detail."},
14        ],
15    }],
16    max_tokens=1024,
17)

1# Multiple images in one message
2messages = [{
3    "role": "user",
4    "content": [
5        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64_1}"}},
6        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64_2}"}},
7        {"type": "text", "text": "Compare these two images."},
8    ],
9}]

1# Vision + thinking combined
2response = client.chat.completions.create(
3    model="gemma-4-26b-a4b",
4    messages=[{
5        "role": "user",
6        "content": [
7            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
8            {"type": "text", "text": "What breed is this dog? Analyze carefully."},
9        ],
10    }],
11    max_tokens=2048,
12    extra_body={"chat_template_kwargs": {"enable_thinking": True}},
13)
14
15raw = response.choices[0].message.model_dump()
16print(f"Thinking: {raw.get('reasoning_content', '')[:200]}")
17print(f"Answer: {response.choices[0].message.content}")

1# ENABLE thinking (explicit)
2response = client.chat.completions.create(
3    model="gemma-4-26b-a4b",
4    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
5    max_tokens=4096,
6    extra_body={"chat_template_kwargs": {"enable_thinking": True}},
7)
8
9msg = response.choices[0].message
10raw = msg.model_dump()
11
12thinking = raw.get("reasoning_content") or ""  # chain-of-thought
13answer = msg.content or ""                      # final response
14
15print(f"Thinking ({len(thinking)} chars): {thinking[:200]}...")
16print(f"Answer: {answer}")

1# DISABLE thinking (explicit)
2response = client.chat.completions.create(
3    model="gemma-4-26b-a4b",
4    messages=[{"role": "user", "content": "What is 2+2?"}],
5    max_tokens=64,
6    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
7)
8
9# reasoning_content will be empty
10print(response.choices[0].message.content)

1# Thinking with token budget — limit thinking to 256 tokens
2response = client.chat.completions.create(
3    model="gemma-4-26b-a4b",
4    messages=[{"role": "user", "content": "Solve 23 * 47"}],
5    max_tokens=1024,
6    extra_body={
7        "chat_template_kwargs": {"enable_thinking": True},
8        "thinking_budget_tokens": 256,
9    },
10)
11
12# Anthropic-compatible format also works:
13response = client.chat.completions.create(
14    model="gemma-4-26b-a4b",
15    messages=[{"role": "user", "content": "Solve 23 * 47"}],
16    max_tokens=1024,
17    extra_body={
18        "thinking": {"type": "enabled", "budget_tokens": 256},
19    },
20)

1# Streaming with reasoning_content
2stream = client.chat.completions.create(
3    model="gemma-4-26b-a4b",
4    messages=[{"role": "user", "content": "Explain quantum computing."}],
5    stream=True,
6    max_tokens=2048,
7    extra_body={"chat_template_kwargs": {"enable_thinking": True}},
8)
9
10for chunk in stream:
11    if not chunk.choices:
12        continue
13    delta = chunk.choices[0].delta
14    raw = delta.model_dump()
15
16    reasoning = raw.get("reasoning_content") or ""
17    content = delta.content or ""
18
19    if reasoning:
20        # Thinking tokens stream here first
21        print(f"[think] {reasoning}", end="", flush=True)
22    if content:
23        # Response tokens stream after thinking completes
24        print(content, end="", flush=True)

1# Define tools in standard OpenAI format
2tools = [
3    {
4        "type": "function",
5        "function": {
6            "name": "get_weather",
7            "description": "Get the current weather for a location.",
8            "parameters": {
9                "type": "object",
10                "properties": {
11                    "location": {"type": "string", "description": "City name"},
12                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
13                },
14                "required": ["location"],
15            },
16        },
17    },
18]

1import json
2
3messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]
4
5# Step 1: Send query with tools
6response = client.chat.completions.create(
7    model="gemma-4-26b-a4b",
8    messages=messages,
9    tools=tools,
10    max_tokens=512,
11)
12
13msg = response.choices[0].message
14
15if msg.tool_calls:
16    # Step 2: Execute tool(s) locally
17    messages.append(msg)
18    for tc in msg.tool_calls:
19        print(f"Tool call: {tc.function.name}({tc.function.arguments})")
20
21        # Your tool implementation here
22        result = {"location": "Tokyo", "temp": 22, "condition": "Sunny"}
23
24        messages.append({
25            "role": "tool",
26            "tool_call_id": tc.id,
27            "content": json.dumps(result),
28        })
29
30    # Step 3: Get final answer
31    response = client.chat.completions.create(
32        model="gemma-4-26b-a4b",
33        messages=messages,
34        tools=tools,
35        max_tokens=512,
36    )
37    print(response.choices[0].message.content)
38else:
39    # Model answered directly without tools
40    print(msg.content)

1from langchain_openai import ChatOpenAI
2
3llm = ChatOpenAI(
4    base_url="https://<app>.modal.run/v1",
5    api_key="YOUR_KEY",
6    model="gemma-4-26b-a4b",
7    temperature=1.0,
8    max_tokens=512,
9)
10
11result = llm.invoke("Explain quantum computing.")
12print(result.content)

1import litellm
2
3response = litellm.completion(
4    model="openai/gemma-4-26b-a4b",
5    api_base="https://<app>.modal.run/v1",
6    api_key="YOUR_KEY",
7    messages=[{"role": "user", "content": "Hello"}],
8)
9print(response.choices[0].message.content)

1import OpenAI from "openai";
2
3const client = new OpenAI({
4  baseURL: "https://<app>.modal.run/v1",
5  apiKey: "YOUR_KEY",
6});
7
8const response = await client.chat.completions.create({
9  model: "gemma-4-26b-a4b",
10  messages: [{ role: "user", content: "Hello!" }],
11  max_tokens: 256,
12});
13
14console.log(response.choices[0].message.content);

1curl -X POST https://<app>.modal.run/v1/chat/completions \
2  -H "Authorization: Bearer YOUR_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "gemma-4-26b-a4b",
6    "messages": [{"role": "user", "content": "Hello!"}],
7    "stream": true,
8    "temperature": 1.0,
9    "top_p": 0.95,
10    "max_tokens": 256
11  }'