DeepSeek 开发文档

export DAYWORLD_API_KEY="YOUR_DAYWORLD_API_KEY"
export DAYWORLD_BASE_URL="https://api.example.com/v1"
export DAYWORLD_MODEL="deepseek-flash"

$env:DAYWORLD_API_KEY = "YOUR_DAYWORLD_API_KEY"
$env:DAYWORLD_BASE_URL = "https://api.example.com/v1"
$env:DAYWORLD_MODEL = "deepseek-flash"

curl --fail-with-body --silent --show-error \
  "$DAYWORLD_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $DAYWORLD_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @- <<JSON
{
  "model": "$DAYWORLD_MODEL",
  "messages": [{"role": "user", "content": "Explain an API in one short sentence."}],
  "thinking": {"type": "disabled"},
  "max_tokens": 256,
  "stream": false
}
JSON

$body = @{
  model = $env:DAYWORLD_MODEL
  messages = @(@{role="user"; content="Explain an API in one short sentence."})
  thinking = @{type="disabled"}
  max_tokens = 256
  stream = $false
} | ConvertTo-Json -Depth 8
$request = @{
  Method = "Post"
  Uri = "$env:DAYWORLD_BASE_URL/chat/completions"
  Headers = @{Authorization="Bearer $env:DAYWORLD_API_KEY"}
  ContentType = "application/json"
  Body = $body
}
$result = Invoke-RestMethod @request
$result.choices[0].message.content

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DAYWORLD_API_KEY"],
    base_url=os.environ["DAYWORLD_BASE_URL"],
    timeout=90.0,
    max_retries=0,
)
result = client.chat.completions.create(
    model=os.environ["DAYWORLD_MODEL"],
    messages=[{"role": "user", "content": "Explain an API in one short sentence."}],
    max_tokens=256,
    extra_body={"thinking": {"type": "disabled"}},
)
print(result.choices[0].message.content)
print(result.usage)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DAYWORLD_API_KEY,
  baseURL: process.env.DAYWORLD_BASE_URL,
  timeout: 90_000,
  maxRetries: 0,
});
const result = await client.chat.completions.create({
  model: process.env.DAYWORLD_MODEL,
  messages: [{role: "user", content: "Explain an API in one short sentence."}],
  thinking: {type: "disabled"},
  max_tokens: 256,
});
console.log(result.choices[0].message.content);
console.log(result.usage);

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["DAYWORLD_API_KEY"],
                base_url=os.environ["DAYWORLD_BASE_URL"],
                timeout=90.0, max_retries=0)
with client.chat.completions.create(
    model=os.environ["DAYWORLD_MODEL"],
    messages=[{"role": "user", "content": "Give three short tips for writing readable code."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=512,
    extra_body={"thinking": {"type": "disabled"}},
) as stream:
    for chunk in stream:
        if chunk.usage is not None:
            print("\nUsage:", chunk.usage)
        if not chunk.choices:
            continue
        text = chunk.choices[0].delta.content
        if text:
            print(text, end="", flush=True)
print()

curl --no-buffer --fail-with-body --silent --show-error \
  "$DAYWORLD_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $DAYWORLD_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @- <<JSON
{"model":"$DAYWORLD_MODEL","messages":[{"role":"user","content":"Reply with OK."}],"stream":true,"max_tokens":256,"thinking":{"type":"disabled"}}
JSON

# Reuse the OpenAI client from the quickstart.
result = client.responses.create(
    model=os.environ["DAYWORLD_MODEL"],
    input=[{"role": "user", "content": "Explain an API in one short sentence."}],
    reasoning={"effort": "none"},
    max_output_tokens=256,
    store=False,
)
print(result.output_text)

{
  "model": "deepseek-flash",
  "input": [
    {
      "role": "user",
      "content": "Reply with OK."
    }
  ],
  "reasoning": {
    "effort": "none"
  },
  "max_output_tokens": 256,
  "store": false,
  "stream": false
}

# Reuse the OpenAI client from the quickstart.
with client.responses.create(
    model=os.environ["DAYWORLD_MODEL"], input="Give three short study tips.",
    reasoning={"effort": "none"}, max_output_tokens=512,
    store=False, stream=True,
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type in {"response.failed", "response.incomplete"}:
            raise RuntimeError(f"Generation ended with {event.type}")
        elif event.type == "response.completed":
            print("\nUsage:", event.response.usage)

curl --fail-with-body --silent --show-error \
  "https://api.example.com/v1/messages" \
  -H "x-api-key: $DAYWORLD_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  --data-binary @- <<JSON
{"model":"$DAYWORLD_MODEL","max_tokens":256,"thinking":{"type":"disabled"},"messages":[{"role":"user","content":"Reply with OK."}]}
JSON

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["DAYWORLD_API_KEY"],
    base_url="https://api.example.com",
    timeout=90.0, max_retries=0,
)
result = client.messages.create(
    model=os.environ["DAYWORLD_MODEL"],
    max_tokens=256,
    thinking={"type": "disabled"},
    messages=[{"role": "user", "content": "Reply with OK."}],
)
print("".join(block.text for block in result.content if block.type == "text"))