> ## Documentation Index
> Fetch the complete documentation index at: https://quwan-b8010aef.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude 基础对话示例

> 使用Claude API进行基础文本对话的完整示例代码

# Claude 基础对话示例

以下示例展示如何使用Claude的 `/v1/messages` 接口进行基础文本对话。

## 快速开始

只需要替换 `YOUR_API_KEY` 为你的实际API密钥即可运行。

```bash cURL theme={null}
curl -X POST "https://api.tokenops.ai/v1/messages" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-3-7-sonnet-20250219",
    "max_tokens": 1000,
    "messages": [
      {
        "role": "user",
        "content": "你好，请介绍一下你自己"
      }
    ]
  }'
```

```python Python theme={null}
import requests
import json

# 配置API密钥和基础URL
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.tokenops.ai/v1"

def chat_with_claude(message):
    url = f"{BASE_URL}/messages"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {API_KEY}",
        "anthropic-version": "2023-06-01"
    }
    
    data = {
        "model": "claude-3-7-sonnet-20250219",
        "max_tokens": 1000,
        "messages": [
            {
                "role": "user",
                "content": message
            }
        ]
    }
    
    response = requests.post(url, headers=headers, json=data)
    
    if response.status_code == 200:
        result = response.json()
        return result['content'][0]['text']
    else:
        return f"错误: {response.status_code} - {response.text}"

# 使用示例
if __name__ == "__main__":
    message = "你好，请介绍一下你自己"
    reply = chat_with_claude(message)
    print(f"Claude回复: {reply}")
```

```javascript JavaScript/Node.js theme={null}
const axios = require('axios');

// 配置API密钥和基础URL
const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.tokenops.ai/v1';

async function chatWithClaude(message) {
    const url = `${BASE_URL}/messages`;
    
    const headers = {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`,
        'anthropic-version': '2023-06-01'
    };
    
    const data = {
        model: 'claude-3-7-sonnet-20250219',
        max_tokens: 1000,
        messages: [
            {
                role: 'user',
                content: message
            }
        ]
    };
    
    try {
        const response = await axios.post(url, data, { headers });
        return response.data.content[0].text;
    } catch (error) {
        return `错误: ${error.response?.status} - ${error.response?.data || error.message}`;
    }
}

// 使用示例
(async () => {
    const message = '你好，请介绍一下你自己';
    const reply = await chatWithClaude(message);
    console.log(`Claude回复: ${reply}`);
})();
```

```go Go theme={null}
package main

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

const (
    APIKey  = "YOUR_API_KEY"
    BaseURL = "https://api.tokenops.ai/v1"
)

type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type ClaudeRequest struct {
    Model     string    `json:"model"`
    MaxTokens int       `json:"max_tokens"`
    Messages  []Message `json:"messages"`
}

type ContentBlock struct {
    Text string `json:"text"`
}

type ClaudeResponse struct {
    Content []ContentBlock `json:"content"`
}

func chatWithClaude(message string) (string, error) {
    url := fmt.Sprintf("%s/messages", BaseURL)
    
    reqData := ClaudeRequest{
        Model:     "claude-3-7-sonnet-20250219",
        MaxTokens: 1000,
        Messages: []Message{
            {
                Role:    "user",
                Content: message,
            },
        },
    }
    
    jsonData, err := json.Marshal(reqData)
    if err != nil {
        return "", err
    }
    
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return "", err
    }
    
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", APIKey))
    req.Header.Set("anthropic-version", "2023-06-01")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }
    
    if resp.StatusCode != 200 {
        return "", fmt.Errorf("API错误: %d - %s", resp.StatusCode, string(body))
    }
    
    var claudeResp ClaudeResponse
    err = json.Unmarshal(body, &claudeResp)
    if err != nil {
        return "", err
    }
    
    return claudeResp.Content[0].Text, nil
}

func main() {
    message := "你好，请介绍一下你自己"
    reply, err := chatWithClaude(message)
    if err != nil {
        fmt.Printf("错误: %v\n", err)
        return
    }
    
    fmt.Printf("Claude回复: %s\n", reply)
}
```

```java Java theme={null}
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

public class ClaudeBasicChat {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "https://api.tokenops.ai/v1";
    
    public static class Message {
        public String role;
        public String content;
        
        public Message(String role, String content) {
            this.role = role;
            this.content = content;
        }
    }
    
    public static class ClaudeRequest {
        public String model;
        public int max_tokens;
        public Message[] messages;
        
        public ClaudeRequest(String model, int maxTokens, Message[] messages) {
            this.model = model;
            this.max_tokens = maxTokens;
            this.messages = messages;
        }
    }
    
    public static String chatWithClaude(String message) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        ObjectMapper mapper = new ObjectMapper();
        
        ClaudeRequest request = new ClaudeRequest(
            "claude-3-7-sonnet-20250219",
            1000,
            new Message[]{new Message("user", message)}
        );
        
        String jsonBody = mapper.writeValueAsString(request);
        
        HttpRequest httpRequest = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/messages"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer " + API_KEY)
            .header("anthropic-version", "2023-06-01")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        
        HttpResponse<String> response = client.send(httpRequest, HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() == 200) {
            JsonNode jsonResponse = mapper.readTree(response.body());
            return jsonResponse.get("content").get(0).get("text").asText();
        } else {
            throw new RuntimeException("API错误: " + response.statusCode() + " - " + response.body());
        }
    }
    
    public static void main(String[] args) {
        try {
            String message = "你好，请介绍一下你自己";
            String reply = chatWithClaude(message);
            System.out.println("Claude回复: " + reply);
        } catch (Exception e) {
            System.err.println("错误: " + e.getMessage());
        }
    }
}
```

```php PHP theme={null}
<?php

class ClaudeBasicChat {
    private $apiKey;
    private $baseUrl;
    
    public function __construct($apiKey, $baseUrl = 'https://api.tokenops.ai/v1') {
        $this->apiKey = $apiKey;
        $this->baseUrl = $baseUrl;
    }
    
    public function chatWithClaude($message) {
        $url = $this->baseUrl . '/messages';
        
        $data = [
            'model' => 'claude-3-7-sonnet-20250219',
            'max_tokens' => 1000,
            'messages' => [
                [
                    'role' => 'user',
                    'content' => $message
                ]
            ]
        ];
        
        $options = [
            'http' => [
                'header' => [
                    'Content-Type: application/json',
                    'Authorization: Bearer ' . $this->apiKey,
                    'anthropic-version: 2023-06-01'
                ],
                'method' => 'POST',
                'content' => json_encode($data)
            ]
        ];
        
        $context = stream_context_create($options);
        $response = file_get_contents($url, false, $context);
        
        if ($response === FALSE) {
            return '请求失败';
        }
        
        $responseData = json_decode($response, true);
        
        if (isset($responseData['content'][0]['text'])) {
            return $responseData['content'][0]['text'];
        } else {
            return '解析响应失败: ' . $response;
        }
    }
}

// 使用示例
$apiKey = 'YOUR_API_KEY';
$chat = new ClaudeBasicChat($apiKey);

$message = '你好，请介绍一下你自己';
$reply = $chat->chatWithClaude($message);

echo "Claude回复: " . $reply . "\n";

?>
```

## 结果示例

```bash 200 theme={null}
{
  "id": "d464daaecced48c0955463907cd814f3",
  "content": [
    {
      "citations": null,
      "text": "你好！我是Claude，由Anthropic创建的AI助手。我被设计来进行有帮助、无害且诚实的对话。我可以回答问题、提供信息、协助创意写作、讨论各种话题，以及帮助完成多种任务。\n\n我具有广泛的知识，但我的训练\n\n我致力于提供准确、有益且符合道德的回应，同时尊重隐私和安全。如果有什么我能帮助你的，请告诉我！",
      "type": "text",
      "signature": "",
      "thinking": "",
      "data": "",
      "id": "",
      "input": null,
      "name": "",
      "content": {
        "OfWebSearchResultBlockArray": null,
        "error_code": "",
        "type": "web_search_tool_result_error"
      },
      "tool_use_id": ""
    }
  ],
  "model": "claude-3-7-sonnet-20250219",
  "role": "assistant",
  "stop_reason": "end_turn",
  "stop_sequence": "",
  "type": "message",
  "usage": {
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "input_tokens": 20,
    "output_tokens": 198,
    "server_tool_use": {
      "web_search_requests": 0
    },
    "service_tier": ""
  }
}
```

```bash 401 theme={null}
{
    "type": "error",
    "request_id": "c3df34c6c0fd427eb321d3e999f62c38",
    "error": {
        "type": "The API key in the request is missing or invalid",
        "message": "请求携带的 API Key 校验未通过，请您重新检查设置的鉴权凭证，或者查看 API 调用文档来排查问题。"
    }
}
```

## 重要参数说明

* **model**: Claude模型名称，如 `claude-3-7-sonnet-20250219`、`claude-3-haiku-20240307` 等
* **max\_tokens**: 最大生成token数量，Claude要求必须指定此参数
* **messages**: 对话消息数组，包含角色（role）和内容（content）
* **anthropic-version**: API版本号，建议使用 `2023-06-01`

## 支持的模型

* claude-sonnet-4-20250514
* claude-opus-4-250514
* claude-3-7-sonnet-20250219
* claude-3-5-sonnet-20241022

## Claude API特点

* **响应格式**: Claude返回的内容在 `content` 数组中，每个元素包含 `text` 字段
* **必需头部**: 需要包含 `anthropic-version` 头部
* **token限制**: 必须指定 `max_tokens` 参数，不能省略

## 错误处理

Claude API的常见错误码：

* **400 Bad Request**: 请求参数错误
* **401 Unauthorized**: API密钥无效
* **429 Rate Limit Exceeded**: 请求频率超限
* **500 Internal Server Error**: 服务器内部错误


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.