from openai import OpenAI
 
# Initialize the OpenAI client with Qubrid base URL
client = OpenAI(
    base_url="https://platform.qubrid.com/v1",
    api_key="QUBRID_API_KEY",
)
 
# Create a streaming chat completion
stream = client.chat.completions.create(
    model="zai-org/GLM-4.7-FP8",
    messages=[
      {
        "role": "user",
        "content": "Explain quantum computing in simple terms"
      }
    ],
    max_tokens=4096,
    temperature=0.6,
    top_p=1,
    stream=True
)
 
# If stream = False comment this out
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print("\n")
 
# If stream = True comment this out
print(stream.choices[0].message.content)

import OpenAI from "openai";
 
// Initialize the OpenAI client with Qubrid base URL
const client = new OpenAI({
  baseURL: "https://platform.qubrid.com/v1",
  apiKey: "QUBRID_API_KEY",
});
 
// Create a streaming chat completion
const stream = await client.chat.completions.create({
  model: "zai-org/GLM-4.7-FP8",
  messages: [
    {
      role: "user",
      content: "Explain quantum computing in simple terms",
    },
  ],
  max_tokens: 4096,
  temperature: 0.6,
  top_p: 1,
  stream: true,
});
 
// If stream = false comment this out
for await (const chunk of stream) {
  if (chunk.choices[0]?.delta?.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}
console.log("\n");
 
// If stream = true comment this out
console.log(stream.choices[0].message.content);

package main
 
import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)
 
func main() {
	url := "https://platform.qubrid.com/v1/chat/completions"
 
	data := map[string]interface{}{
		"model": "zai-org/GLM-4.7-FP8",
		"messages": []map[string]string{
			{
				"role":    "user",
				"content": "Explain quantum computing in simple terms",
			},
		},
		"temperature": 0.6,
		"max_tokens":  4096,
		"stream":      true,
		"top_p":       1,
	}
 
	jsonData, _ := json.Marshal(data)
	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	req.Header.Set("Authorization", "Bearer QUBRID_API_KEY")
	req.Header.Set("Content-Type", "application/json")
 
	client := &http.Client{}
	res, _ := client.Do(req)
	defer res.Body.Close()
 
	scanner := bufio.NewScanner(res.Body)
	for scanner.Scan() {
		line := scanner.Text()
		if line != "" {
			fmt.Println(line)
		}
	}
}

curl -X POST "https://platform.qubrid.com/v1/chat/completions" \
  -H "Authorization: Bearer QUBRID_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "zai-org/GLM-4.7-FP8",
  "messages": [
    {
      "role": "user",
      "content": "Explain quantum computing in simple terms"
    }
  ],
  "temperature": 0.6,
  "max_tokens": 4096,
  "stream": true,
  "top_p": 1
}'

<think>
Classic algorithm request. I'll implement the Sieve of Eratosthenes cleanly
with proper type hints, a docstring, and an example usage block.
I'll also note the time complexity for completeness.
</think>
 
def sieve_of_eratosthenes(n: int) -> list[int]:
    """
    Return all prime numbers up to and including n
    using the Sieve of Eratosthenes.
 
    Time complexity:  O(n log log n)
    Space complexity: O(n)
 
    Args:
        n: Upper bound (inclusive) for prime search.
 
    Returns:
        Sorted list of all primes <= n.
    """
    if n < 2:
        return []
 
    # Initialize boolean array: True = potentially prime
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
 
    # Sieve: mark multiples of each prime as composite
    p = 2
    while p * p <= n:
        if is_prime[p]:
            for multiple in range(p * p, n + 1, p):
                is_prime[multiple] = False
        p += 1
 
    return [i for i, prime in enumerate(is_prime) if prime]
 
 
# Example usage
if __name__ == "__main__":
    primes = sieve_of_eratosthenes(50)
    print(primes)
    # Output: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

Example: "You are a senior software engineer. For every coding task:
1. Think through the approach before writing any code.
2. Write clean, production-ready code with type hints and docstrings.
3. Include edge case handling and a brief complexity analysis."