---
url: /guide/text-generation/index.md
---
文本生成是智算多多 API 的核心能力，支持对话、写作、翻译、摘要等多种场景。本文档提供常用编程语言的调用示例。

## 基础请求示例

::: code-tabs#basic

@tab Python

```python
from openai import OpenAI

# 初始化客户端
client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.zsdodo.com/v1"
)

# 发送请求
response = client.chat.completions.create(
    model="qwen-plus",
    messages=[
        {"role": "system", "content": "你是一个有帮助的助手。"},
        {"role": "user", "content": "请介绍一下智算多多。"}
    ]
)

# 获取回复
print(response.choices[0].message.content)
```

@tab JavaScript

```javascript
import OpenAI from 'openai';

// 初始化客户端
const client = new OpenAI({
  apiKey: 'your-api-key',
  baseURL: 'https://api.zsdodo.com/v1'
});

// 发送请求
async function chat() {
  const response = await client.chat.completions.create({
    model: 'qwen-plus',
    messages: [
      { role: 'system', content: '你是一个有帮助的助手。' },
      { role: 'user', content: '请介绍一下智算多多。' }
    ]
  });

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

chat();
```

@tab Java

```java
import com.theokanning.openai.service.OpenAiService;
import com.theokanning.openai.completion.chat.*;
import java.util.*;

public class TextGeneration {
    public static void main(String[] args) {
        // 初始化服务
        OpenAiService service = new OpenAiService(
            "your-api-key",
            "https://api.zsdodo.com/v1"
        );
        
        // 构建消息
        List<ChatMessage> messages = new ArrayList<>();
        messages.add(new ChatMessage("system", "你是一个有帮助的助手。"));
        messages.add(new ChatMessage("user", "请介绍一下智算多多。"));
        
        // 构建请求
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("qwen-plus")
            .messages(messages)
            .build();
        
        // 发送请求并获取结果
        ChatCompletionResult result = service.createChatCompletion(request);
        System.out.println(result.getChoices().get(0).getMessage().getContent());
        
        service.shutdownExecutor();
    }
}
```

@tab Go

```go
package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    // 初始化客户端
    client := openai.NewClientWithConfig(openai.ClientConfig{
        BaseURL: "https://api.zsdodo.com/v1",
        APIKey:  "your-api-key",
    })
    
    // 发送请求
    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: openai.GPT4, // 替换为智算多多支持的模型
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleSystem,
                    Content: "你是一个有帮助的助手。",
                },
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: "请介绍一下智算多多。",
                },
            },
        },
    )
    
    if err != nil {
        fmt.Printf("请求错误: %v\n", err)
        return
    }
    
    fmt.Println(resp.Choices[0].Message.Content)
}
```

@tab bash

```bash
curl -X POST https://api.zsdodo.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "model": "qwen-plus",
    "messages": [
      {"role": "system", "content": "你是一个有帮助的助手。"},
      {"role": "user", "content": "请介绍一下智算多多。"}
    ]
  }'
```

:::

## 流式输出示例

流式输出适用于长文本生成场景，可实时获取内容，提升用户体验。

::: code-tabs#stream

@tab Python

```python
stream = client.chat.completions.create(
    model="qwen-plus",
    messages=[
        {"role": "user", "content": "请写一篇关于AI发展的短文。"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

@tab JavaScript

```javascript
const stream = await client.chat.completions.create({
  model: 'qwen-plus',
  messages: [
    { role: 'user', content: '请写一篇关于AI发展的短文。' }
  ],
  stream: true
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content || '';
  process.stdout.write(content);
}
```

@tab Java

```java
// Java 流式输出使用 SSE (Server-Sent Events)
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
    .url("https://api.zsdodo.com/v1/chat/completions")
    .header("Authorization", "Bearer your-api-key")
    .header("Content-Type", "application/json")
    .post(RequestBody.create(
        MediaType.parse("application/json"),
        "{\"model\":\"qwen-plus\",\"messages\":[{\"role\":\"user\",\"content\":\"请写一篇关于AI发展的短文。\"}],\"stream\":true}"
    ))
    .build();

EventSource.Factory factory = EventSources.createFactory(client);
EventSource.Listener listener = new EventSource.Listener() {
    @Override
    public void onEvent(EventSource eventSource, String id, String type, String data) {
        if (!data.equals("[DONE]")) {
            // 解析 JSON 并输出内容
            JSONObject json = new JSONObject(data);
            String content = json.getJSONArray("choices")
                .getJSONObject(0)
                .getJSONObject("delta")
                .optString("content", "");
            System.out.print(content);
        }
    }
};
```

@tab Go

```go
stream, err := client.CreateChatCompletionStream(
    context.Background(),
    openai.ChatCompletionRequest{
        Model: "qwen-plus",
        Messages: []openai.ChatCompletionMessage{
            {
                Role:    openai.ChatMessageRoleUser,
                Content: "请写一篇关于AI发展的短文。",
            },
        },
        Stream: true,
    },
)
if err != nil {
    log.Fatalf("Stream error: %v\n", err)
}
defer stream.Close()

for {
    response, err := stream.Recv()
    if err == io.EOF {
        break
    }
    if err != nil {
        log.Fatalf("Stream recv error: %v\n", err)
    }
    fmt.Print(response.Choices[0].Delta.Content)
}
```

@tab bash

```bash
curl -X POST https://api.zsdodo.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "model": "qwen-plus",
    "messages": [{"role": "user", "content": "请写一篇关于AI发展的短文。"}],
    "stream": true
  }' --no-buffer
```

:::

## 多轮对话示例

::: code-tabs#multi-turn

@tab Python

```python
messages = [
    {"role": "system", "content": "你是一个有帮助的助手。"}
]

while True:
    user_input = input("用户: ")
    if user_input.lower() in ["退出", "quit", "exit"]:
        break
    
    # 添加用户消息
    messages.append({"role": "user", "content": user_input})
    
    # 发送请求
    response = client.chat.completions.create(
        model="qwen-plus",
        messages=messages
    )
    
    assistant_reply = response.choices[0].message.content
    print(f"助手: {assistant_reply}")
    
    # 添加助手回复到历史
    messages.append({"role": "assistant", "content": assistant_reply})
```

@tab JavaScript

```javascript
const messages = [
  { role: 'system', content: '你是一个有帮助的助手。' }
];

async function chat(userInput) {
  messages.push({ role: 'user', content: userInput });

  const response = await client.chat.completions.create({
    model: 'qwen-plus',
    messages
  });

  const reply = response.choices[0].message.content;
  messages.push({ role: 'assistant', content: reply });

  return reply;
}

// 使用示例
(async () => {
  console.log(await chat('你好！'));
  console.log(await chat('请介绍一下你自己。'));
})();
```

:::

## 参数说明

| 参数 | 类型 | 说明 | 默认值 |
|-----|------|------|-------|
| `model` | string | 模型名称，见 [模型列表](./models.md) | 必填 |
| `messages` | array | 消息列表，包含 role 和 content | 必填 |
| `temperature` | float | 随机性控制，0-2，越高越随机 | 1 |
| `max_tokens` | int | 最大输出 Token 数 | 不限 |
| `top_p` | float | 核采样参数，0-1 | 1 |
| `stream` | bool | 是否流式输出 | false |
| `presence_penalty` | float | 存在惩罚，-2 到 2 | 0 |
| `frequency_penalty` | float | 频率惩罚，-2 到 2 | 0 |

::: tip 调优建议

* **精确输出**：设置 `temperature=0`，输出更确定性
* **创意写作**：设置 `temperature=0.7-1.5`，增加多样性
* **控制长度**：设置 `max_tokens` 限制输出长度
* **避免重复**：设置 `frequency_penalty=0.5-1` 减少重复内容
  :::

## 错误处理示例

::: code-tabs#error

@tab Python

```python
from openai import OpenAI, APIError, APIConnectionError, RateLimitError

try:
    response = client.chat.completions.create(
        model="qwen-plus",
        messages=[{"role": "user", "content": "你好"}]
    )
    print(response.choices[0].message.content)

except RateLimitError as e:
    print(f"请求超限: {e}")
    # 等待后重试

except APIConnectionError as e:
    print(f"连接错误: {e}")
    # 检查网络或重试

except APIError as e:
    print(f"API 错误: {e}")
    # 检查请求参数
```

@tab JavaScript

```javascript
try {
  const response = await client.chat.completions.create({
    model: 'qwen-plus',
    messages: [{ role: 'user', content: '你好' }]
  });
  console.log(response.choices[0].message.content);
} catch (error) {
  if (error.status === 429) {
    console.log('请求超限，请稍后重试');
  } else if (error.status === 500) {
    console.log('服务端错误，请检查请求参数');
  } else {
    console.log(`错误: ${error.message}`);
  }
}
```

:::

## SDK 安装参考

| 语言 | SDK | 安装命令 |
|-----|-----|---------|
| Python | openai | `pip install openai` |
| JavaScript | openai | `npm install openai` |
| Java | openai-java | Maven/Gradle 依赖 |
| Go | go-openai | `go get github.com/sashabaranov/go-openai` |
| PHP | openai-php | `composer require openai-php/client` |
| Ruby | ruby-openai | `gem install ruby-openai` |
| C# | OpenAI-SDK | NuGet 安装 |

::: info 提示
智算多多兼容 OpenAI API 协议，可直接使用各语言的 OpenAI SDK，只需修改 `base_url` 参数即可。
:::