Qwen3.8 Max verwenden: Python, TypeScript und cURL

export EVOLINK_API_KEY="your-evolink-api-key"
export EVOLINK_BASE_URL="https://direct.evolink.ai/v1"
export EVOLINK_QWEN_MODEL="qwen3.8-max-preview"

Existing OpenAI-compatible chat application?
├─ Yes → Chat Completions
└─ No
   ├─ New agent needs built-in tools or server-linked turns? → Responses
   └─ Existing Anthropic Messages stack? → Messages

curl --request POST \
  --url "${EVOLINK_BASE_URL}/chat/completions" \
  --header "Authorization: Bearer ${EVOLINK_API_KEY}" \
  --header "Content-Type: application/json" \
  --data "{
    \"model\": \"${EVOLINK_QWEN_MODEL}\",
    \"messages\": [
      {
        \"role\": \"system\",
        \"content\": \"You are a concise software architecture assistant.\"
      },
      {
        \"role\": \"user\",
        \"content\": \"Return three checks for a safe API rollout.\"
      }
    ]
  }"

pip install openai

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["EVOLINK_API_KEY"],
    base_url=os.getenv("EVOLINK_BASE_URL", "https://direct.evolink.ai/v1"),
)

response = client.chat.completions.create(
    model=os.environ["EVOLINK_QWEN_MODEL"],
    messages=[
        {
            "role": "system",
            "content": "You are a concise software architecture assistant.",
        },
        {
            "role": "user",
            "content": "Return three checks for a safe API rollout.",
        },
    ],
)

print(response.choices[0].message.content)
print(response.model)

npm install openai

import OpenAI from "openai";

const apiKey = process.env.EVOLINK_API_KEY;
const model = process.env.EVOLINK_QWEN_MODEL;

if (!apiKey || !model) {
  throw new Error("EVOLINK_API_KEY and EVOLINK_QWEN_MODEL are required");
}

const client = new OpenAI({
  apiKey,
  baseURL: process.env.EVOLINK_BASE_URL ?? "https://direct.evolink.ai/v1",
});

const response = await client.chat.completions.create({
  model,
  messages: [
    {
      role: "system",
      content: "You are a concise software architecture assistant.",
    },
    {
      role: "user",
      content: "Return three checks for a safe API rollout.",
    },
  ],
});

console.log(response.choices[0].message.content);
console.log(response.model);

import os
from openai import OpenAI

model = os.environ.get("EVOLINK_QWEN_MODEL")
if not model:
    raise RuntimeError("EVOLINK_QWEN_MODEL is required")

client = OpenAI(
    api_key=os.environ["EVOLINK_API_KEY"],
    base_url=os.getenv("EVOLINK_BASE_URL", "https://direct.evolink.ai/v1"),
)

stream = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "user", "content": "Review this rollout plan for failure modes."}
    ],
    stream=True,
    extra_body={"enable_thinking": True},
)

for chunk in stream:
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        print(reasoning, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)

curl --request POST \
  --url "${EVOLINK_BASE_URL}/responses" \
  --header "Authorization: Bearer ${EVOLINK_API_KEY}" \
  --header "Content-Type: application/json" \
  --header "x-dashscope-session-cache: enable" \
  --data "{
    \"model\": \"${EVOLINK_QWEN_MODEL}\",
    \"input\": \"List the production checks for a model-route canary.\"
  }"

curl --request POST \
  --url "${EVOLINK_BASE_URL}/responses" \
  --header "Authorization: Bearer ${EVOLINK_API_KEY}" \
  --header "Content-Type: application/json" \
  --header "x-dashscope-session-cache: enable" \
  --data "{
    \"model\": \"${EVOLINK_QWEN_MODEL}\",
    \"previous_response_id\": \"resp_FROM_FIRST_CALL\",
    \"input\": \"Turn those checks into a five-step canary plan.\"
  }"

curl --request POST \
  --url "${EVOLINK_BASE_URL}/messages" \
  --header "Authorization: Bearer ${EVOLINK_API_KEY}" \
  --header "Content-Type: application/json" \
  --data "{
    \"model\": \"${EVOLINK_QWEN_MODEL}\",
    \"max_tokens\": 1024,
    \"system\": \"You are a concise software architecture assistant.\",
    \"messages\": [
      {
        \"role\": \"user\",
        \"content\": \"Return three checks for a safe API rollout.\"
      }
    ]
  }"

import { z } from "zod";

const createCanarySchema = z.object({
  workload: z.string().min(1).max(80),
  trafficPercent: z.number().min(0.1).max(10),
});

function validateToolCall(name: string, rawArguments: string) {
  if (name !== "create_canary") {
    throw new Error(`Blocked unknown tool: ${name}`);
  }

  return createCanarySchema.parse(JSON.parse(rawArguments));
}

import os
import random
import time
from openai import APIConnectionError, APIStatusError, APITimeoutError, OpenAI

client = OpenAI(
    api_key=os.environ["EVOLINK_API_KEY"],
    base_url=os.getenv("EVOLINK_BASE_URL", "https://direct.evolink.ai/v1"),
)

def complete_with_fallback(messages):
    models = [
        os.environ["EVOLINK_QWEN_MODEL"],
        os.environ["EVOLINK_FALLBACK_MODEL"],
    ]

    for model in models:
        for attempt in range(3):
            try:
                return client.chat.completions.create(
                    model=model,
                    messages=messages,
                    timeout=60,
                )
            except APIStatusError as error:
                if error.status_code != 429 and error.status_code < 500:
                    raise
            except (APIConnectionError, APITimeoutError):
                pass

            time.sleep((2 ** attempt) + random.random())

    raise RuntimeError("Primary and fallback routes failed")