claude-opus-4-8

最后更新：2026-11-14

POSThttps://www.sagelib.com/chat/completions

claude-opus-4-8 模型的聊天生成接口，OpenAI兼容，支持多轮上下文、流式输出、工具调用、结构化输出等。

接口鉴权方式请参考：API接入与鉴权

请求参数

请求头

参数名称	描述
*Authorization `string`	鉴权令牌，格式为 Bearer ${AIGATEWAY_TOKEN}
*Content-Type `string`	默认值：application/json 可选值：application/json 内容类型，固定为 application/json

Body 参数

参数名称	描述
*model `string`	可选值："claude-opus-4-8" 模型名称，须精确匹配
*messages `array`	可选值：content 对话消息列表，首条须为 user 角色
max_tokens `integer`	可选值：1 ~ 128000 最大输出 token 数，上限 128000
temperature `float`	默认值：1 随机性控制，默认 1.0
top_p `float`	默认值：1 核采样概率阈值，默认 1.0
top_k `integer`	默认值：0 Top-K 采样，默认 0
stream `boolean`	默认值：false 可选值：true、false 是否启用 SSE 流式输出
tools `array`	可选值：Anthropic-format tool definition 工具定义列表，Anthropic 格式：name/description/input_schema
tool_choice `object`	可选值：auto、any、tool、none 工具选择策略
stop `array`	可选值：String array, up to 4 items 停止词列表（OpenAI 兼容格式）
metadata `object`	可选值：Contains user_id sub-field 请求元数据，user_id 禁止含 PII

请求示例

curl -v 'https://www.sagelib.com/chat/completions' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [
      {
        "role": "user",
        "content": "Hello"
      }
    ]
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/chat/completions"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "claude-opus-4-8",
    "messages": [
        {
            "role": "user",
            "content": "Hello"
        }
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/chat/completions";

        String jsonRequestBody = """
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Hello"
                    }
                ]
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/chat/completions"

    jsonRequestBody := `
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Hello"
                    }
                ]
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/chat/completions' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [
      {
        "role": "user",
        "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
      }
    ],
    "max_tokens": 50
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/chat/completions"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "claude-opus-4-8",
    "messages": [
        {
            "role": "user",
            "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
        }
    ],
    "max_tokens": 50
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/chat/completions";

        String jsonRequestBody = """
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
                    }
                ],
                "max_tokens": 50
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/chat/completions"

    jsonRequestBody := `
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
                    }
                ],
                "max_tokens": 50
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/chat/completions' \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [
      {
        "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
        "role": "user"
      }
    ],
    "stream": true
  }'

import json
import requests

# Configure base variables
base_url = "https://www.sagelib.com"  # 把 base_url 换成你的网关地址 https://www.sagelib.com
api_key = "***"  # Replace with your Bearer token

url = f"https://www.sagelib.com/chat/completions"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "claude-opus-4-8",
    "messages": [
        {
            "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
            "role": "user"
        }
    ],
    "stream": True
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the status code and the returned JSON data
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/chat/completions";

        String jsonRequestBody = """
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
                        "role": "user"
                    }
                ],
                "stream": true
            }
            """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody))
                .build();

        try {
            // Use ofInputStream to handle the streaming response
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) {
                            break;
                        }
                        // Tip: you can bring in Gson or Jackson here to parse the JSON in data and extract delta.content
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/chat/completions"

    jsonRequestBody := `
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
                        "role": "user"
                    }
                ],
                "stream": true
            }
`

    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    // Pretty-print the returned JSON data
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

响应参数

Body 参数

参数名称	描述
id `string`	响应唯一标识，如 chatcmpl-xxx
object `string`	固定为 chat.completion
model `string`	实际使用的模型名称
created `integer`	创建时间戳（Unix秒）
choices `array`	生成结果数组
usage `object`
prompt_tokens `integer`	输入 token 数
completion_tokens `integer`	输出 token 数
total_tokens `integer`	总 token 数

POSThttps://www.sagelib.com/anthropic/v1/messages

claude-opus-4-8 模型的聊天生成接口，Anthropic直连，支持多轮上下文、流式输出、工具调用、结构化输出等。

接口鉴权方式请参考：API接入与鉴权

请求参数

请求头

参数名称	描述
*Content-Type `string`	可选值：application/json application/json
*anthropic-version `string`	可选值：2023-06-01 Anthropic API 版本号，固定为 2023-06-01
*X-Api-Key `string`	鉴权令牌，格式为 ${AIGATEWAY_TOKEN}

Body 参数

参数名称	描述
*model `string`	可选值："claude-opus-4-8" 模型名称，须精确匹配
*messages `array`	可选值：content 对话消息列表，首条须为 user 角色，content 可为字符串或内容块数组
*max_tokens `integer`	可选值：1 ~ 128000 最大输出 token 数，上限 128000。Anthropic 协议必填
system `string`	可选值：String or array of TextBlockParam 系统提示词，Anthropic 顶层参数（非 messages 数组内）
temperature `float`	默认值：1 随机性控制，默认 1.0。与 thinking.type=enabled 互斥
top_p `float`	默认值：1 核采样概率阈值，默认 1.0
top_k `integer`	默认值：0 Top-K 采样，默认 0
stream `boolean`	默认值：false 可选值：true、false 是否启用 SSE 流式输出
tools `array`	可选值：Array of Anthropic-format tool definitions 工具定义列表，含 name/description/input_schema
tool_choice `object`	可选值：auto、any、tool、none 工具选择策略，Anthropic 对象格式
thinking `object`	可选值：adaptive、enabled 思考配置。支持 enabled（Extended Thinking，需 budget_tokens >= 1024）
cache_control `object`	可选值：type: ephemeral 缓存控制，最低 1024 tokens
output_config `object`	可选值：medium、high、xhigh、max 输出配置，含推理力度和结构化输出
stop_sequences `array`	可选值：String array, up to 4 items 自定义停止序列
metadata `object`	可选值：Contains user_id sub-field 请求元数据，user_id 禁止含 PII
service_tier `string`	可选值：auto、standard_only 服务层级
container `string`	可选值：String 容器标识符
inference_geo `string`	可选值：String 推理地理区域

请求示例

curl -v 'https://www.sagelib.com/anthropic/messages' \
  -H "x-api-key: ***" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [
      {
        "role": "user",
        "content": "Hello"
      }
    ]
  }'

import json
import requests

base_url = "https://www.sagelib.com"
api_key = "***"
url = f"https://www.sagelib.com/anthropic/messages"
headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01", "Content-Type": "application/json"}
data = {
    "model": "claude-opus-4-8",
    "messages": [
        {
            "role": "user",
            "content": "Hello"
        }
    ]
}
response = requests.post(url, headers=headers, json=data)
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/anthropic/messages";
        String jsonRequestBody = """
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Hello"
                    }
                ]
            }
            """;
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder().uri(URI.create(url)).header("x-api-key", apiKey).header("anthropic-version", "2023-06-01").header("Content-Type", "application/json").POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody)).build();
        try {
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) break;
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) { e.printStackTrace(); }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/anthropic/messages"
    jsonRequestBody := `
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Hello"
                    }
                ]
            }
`
    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil { fmt.Println("Failed to create request:", err); return }
    req.Header.Set("x-api-key", apiKey)
    req.Header.Set("anthropic-version", "2023-06-01")
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil { fmt.Println("Request failed:", err); return }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/anthropic/messages' \
  -H "x-api-key: ***" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [
      {
        "role": "user",
        "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
      }
    ],
    "max_tokens": 50
  }'

import json
import requests

base_url = "https://www.sagelib.com"
api_key = "***"
url = f"https://www.sagelib.com/anthropic/messages"
headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01", "Content-Type": "application/json"}
data = {
    "model": "claude-opus-4-8",
    "messages": [
        {
            "role": "user",
            "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
        }
    ],
    "max_tokens": 50
}
response = requests.post(url, headers=headers, json=data)
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/anthropic/messages";
        String jsonRequestBody = """
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
                    }
                ],
                "max_tokens": 50
            }
            """;
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder().uri(URI.create(url)).header("x-api-key", apiKey).header("anthropic-version", "2023-06-01").header("Content-Type", "application/json").POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody)).build();
        try {
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) break;
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) { e.printStackTrace(); }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/anthropic/messages"
    jsonRequestBody := `
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "role": "user",
                        "content": "Introduce the history of AI in detail, starting from the Turing test in the 1950s, covering expert systems, machine learning, deep learning, and large language models, including key figures, milestones, and technical breakthroughs; elaborate each stage as fully as possible."
                    }
                ],
                "max_tokens": 50
            }
`
    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil { fmt.Println("Failed to create request:", err); return }
    req.Header.Set("x-api-key", apiKey)
    req.Header.Set("anthropic-version", "2023-06-01")
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil { fmt.Println("Request failed:", err); return }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

curl -v 'https://www.sagelib.com/anthropic/messages' \
  -H "x-api-key: ***" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [
      {
        "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
        "role": "user"
      }
    ],
    "stream": true
  }'

import json
import requests

base_url = "https://www.sagelib.com"
api_key = "***"
url = f"https://www.sagelib.com/anthropic/messages"
headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01", "Content-Type": "application/json"}
data = {
    "model": "claude-opus-4-8",
    "messages": [
        {
            "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
            "role": "user"
        }
    ],
    "stream": True
}
response = requests.post(url, headers=headers, json=data)
print(f"Status Code: {response.status_code}")
try:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
except Exception:
    print(response.text)

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class LlmStreamClient {
    public static void main(String[] args) {
        String baseUrl = "https://www.sagelib.com";
        String apiKey = "***";
        String url = "https://www.sagelib.com/anthropic/messages";
        String jsonRequestBody = """
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
                        "role": "user"
                    }
                ],
                "stream": true
            }
            """;
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder().uri(URI.create(url)).header("x-api-key", apiKey).header("anthropic-version", "2023-06-01").header("Content-Type", "application/json").POST(HttpRequest.BodyPublishers.ofString(jsonRequestBody)).build();
        try {
            HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    if (line.startsWith("data:")) {
                        String data = line.substring(5).trim();
                        if ("[DONE]".equals(data)) break;
                        System.out.println("Received stream chunk: " + data);
                    }
                }
            }
        } catch (Exception e) { e.printStackTrace(); }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    baseUrl := "https://www.sagelib.com"
    apiKey := "***"
    url := "https://www.sagelib.com/anthropic/messages"
    jsonRequestBody := `
            {
                "model": "claude-opus-4-8",
                "messages": [
                    {
                        "content": "What model are you? Which company made you? When is your knowledge cutoff? Briefly describe your capability boundaries.",
                        "role": "user"
                    }
                ],
                "stream": true
            }
`
    req, err := http.NewRequest("POST", url, bytes.NewBufferString(jsonRequestBody))
    if err != nil { fmt.Println("Failed to create request:", err); return }
    req.Header.Set("x-api-key", apiKey)
    req.Header.Set("anthropic-version", "2023-06-01")
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil { fmt.Println("Request failed:", err); return }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var prettyBody map[string]interface{}
    if err := json.Unmarshal(body, &prettyBody); err == nil {
        pretty, _ := json.MarshalIndent(prettyBody, "", "  ")
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(pretty))
    } else {
        fmt.Println("Status Code:", resp.StatusCode)
        fmt.Println(string(body))
    }
}

响应参数

Body 参数

参数名称	描述
id `string`	响应唯一标识，如 msg_${message_id}
type `string`	固定为 message
role `string`	固定为 assistant
model `string`	实际使用的模型名称
content `array`	内容块数组
stop_reason `string`	停止原因：end_turn / max_tokens / stop_sequence / tool_use
stop_sequence `string`	匹配的停止序列（stop_reason=stop_sequence 时）
usage `object`
input_tokens `integer`	输入 token 数
output_tokens `integer`	输出 token 数（含推理 token）
cache_creation_input_tokens `integer`	缓存写入 token 数
cache_read_input_tokens `integer`	缓存命中 token 数