跳至主要內容

模型调用

BladeX大约 4 分钟aiapi

统一API接口

BladeX 大模型平台提供了标准化的OpenAPI接口，使开发者能够轻松接入各种大语言模型，而无需关心底层差异。

API特性

  • 统一调用标准：采用RESTful风格API设计，提供一致的请求与响应格式
  • 自动负载均衡：根据调用量和响应时间智能分配模型资源
  • 透明的模型切换：通过简单参数修改即可切换底层模型，无需改动应用代码
  • 调用量控制：支持按用户、应用、模型设置调用频率限制
  • 全链路加密：确保API调用全过程的数据安全

核心API概览

平台提供以下核心API功能：

1. 模型对话API

POST /api/v1/chat/completions

用于发起模型对话请求，支持多轮对话上下文传递。兼容OpenAI标准接口格式。

完整请求参数：

参数名类型必填默认值说明
modelstring是-模型名称，如："gpt-4o", "deepseek-v3", "deepseek-r1"
messagesarray是-消息列表，包含role和content
temperaturenumber否0.7控制输出随机性 (0.0-2.0)
max_tokensinteger否4096最大生成token数
top_pnumber否1.0核采样参数 (0.0-1.0)
frequency_penaltynumber否0.0频率惩罚 (-2.0-2.0)
presence_penaltynumber否0.0存在惩罚 (-2.0-2.0)
stoparray否null停止生成的字符串列表
streamboolean否false是否启用流式响应
userstring否-用户标识符
functionsarray否-可调用的函数列表
function_callstring/object否-控制函数调用行为

Messages格式：

字段名类型必填说明
rolestring是角色：system/user/assistant/function
contentstring是消息内容
namestring否消息发送者名称
function_callobject否函数调用信息

请求示例：

{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "system", 
      "content": "你是一个专业的AI助手，擅长回答技术问题。"
    },
    {
      "role": "user", 
      "content": "请详细介绍深度学习在计算机视觉中的应用"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 2000,
  "top_p": 0.95,
  "frequency_penalty": 0.1,
  "presence_penalty": 0.1,
  "stream": false,
  "user": "user-123"
}

标准响应格式：

{
  "id": "chatcmpl-8xHdG2fV3K8mJ9nLqZ1kP",
  "object": "chat.completion",
  "created": 1704380400,
  "model": "gpt-4o",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "深度学习在计算机视觉领域有着广泛而深入的应用...",
        "function_call": null
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 45,
    "completion_tokens": 280,
    "total_tokens": 325
  }
}

流式响应格式 (当stream=true时)：

data: {"id":"chatcmpl-8xHdG","object":"chat.completion.chunk","created":1704380400,"model":"gpt-4o","choices":[{"index":0,"delta":{"role":"assistant","content":"深度"},"finish_reason":null}]}

data: {"id":"chatcmpl-8xHdG","object":"chat.completion.chunk","created":1704380400,"model":"gpt-4o","choices":[{"index":0,"delta":{"content":"学习"},"finish_reason":null}]}

data: {"id":"chatcmpl-8xHdG","object":"chat.completion.chunk","created":1704380400,"model":"gpt-4o","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

cURL调用示例：

curl -X POST "https://api.bladex.cn/ai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your_api_key_here" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "system",
        "content": "你是一个专业的AI助手"
      },
      {
        "role": "user", 
        "content": "解释一下什么是机器学习"
      }
    ],
    "temperature": 0.7,
    "max_tokens": 1000
  }'

流式调用cURL示例：

curl -X POST "https://api.bladex.cn/ai/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your_api_key_here" \
  -N \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": "写一首关于春天的诗"
      }
    ],
    "stream": true,
    "temperature": 0.8
  }'

JavaScript调用示例：

// 使用fetch进行同步调用
async function chatCompletion() {
  const response = await fetch('https://api.bladex.cn/ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer your_api_key_here'
    },
    body: JSON.stringify({
      model: 'gpt-4o',
      messages: [
        { role: 'system', content: '你是一个专业助手' },
        { role: 'user', content: '请介绍人工智能的发展历程' }
      ],
      temperature: 0.7,
      max_tokens: 1500
    })
  });

  const data = await response.json();
  console.log(data.choices[0].message.content);
}

// 流式调用示例
async function streamChatCompletion() {
  const response = await fetch('https://api.bladex.cn/ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer your_api_key_here'
    },
    body: JSON.stringify({
      model: 'gpt-4o',
      messages: [
        { role: 'user', content: '写一个Python排序算法示例' }
      ],
      stream: true,
      temperature: 0.3
    })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split('\n');
    
    for (const line of lines) {
      if (line.startsWith('data: ')) {
        const data = line.slice(6);
        if (data === '[DONE]') return;
        
        try {
          const parsed = JSON.parse(data);
          const content = parsed.choices[0]?.delta?.content;
          if (content) {
            process.stdout.write(content);
          }
        } catch (e) {
          // 忽略解析错误
        }
      }
    }
  }
}

// 使用async/await
chatCompletion().catch(console.error);

Java调用示例：

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.*;

public class BladeXChatClient {
    
    private final RestTemplate restTemplate = new RestTemplate();
    private final ObjectMapper objectMapper = new ObjectMapper();
    private final String apiKey = "your_api_key_here";
    private final String baseUrl = "https://api.bladex.cn/ai/v1";
    
    /**
     * 同步聊天调用
     */
    public ChatResponse chatCompletion(ChatRequest request) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.setBearerAuth(apiKey);
        
        HttpEntity<ChatRequest> entity = new HttpEntity<>(request, headers);
        
        ResponseEntity<ChatResponse> response = restTemplate.postForEntity(
            baseUrl + "/chat/completions",
            entity,
            ChatResponse.class
        );
        
        return response.getBody();
    }
    
    /**
     * 使用示例
     */
    public void example() {
        // 构建请求
        ChatMessage systemMessage = ChatMessage.builder()
            .role("system")
            .content("你是一个专业的Java开发助手")
            .build();
            
        ChatMessage userMessage = ChatMessage.builder()
            .role("user")
            .content("请解释Spring Boot的自动配置原理")
            .build();
        
        ChatRequest request = ChatRequest.builder()
            .model("gpt-4o")
            .messages(Arrays.asList(systemMessage, userMessage))
            .temperature(0.7)
            .maxTokens(2000)
            .build();
        
        // 发起调用
        ChatResponse response = chatCompletion(request);
        
        // 处理响应
        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
            String content = response.getChoices().get(0).getMessage().getContent();
            System.out.println("AI回复: " + content);
            
            // 打印token使用情况
            ChatUsage usage = response.getUsage();
            System.out.printf("Token使用: 输入=%d, 输出=%d, 总计=%d%n",
                usage.getPromptTokens(),
                usage.getCompletionTokens(), 
                usage.getTotalTokens());
        }
    }
}

/**
 * 请求模型类
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChatRequest {
    private String model;
    private List<ChatMessage> messages;
    private Double temperature;
    private Integer maxTokens;
    private Double topP;
    private Boolean stream;
    private String user;
}

/**
 * 响应模型类
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChatResponse {
    private String id;
    private String object;
    private Integer created;
    private String model;
    private List<ChatChoice> choices;
    private ChatUsage usage;
}

DeepSeek-R1推理模式特殊用法：

// DeepSeek-R1推理模式调用
const deepseekResponse = await fetch('https://api.bladex.cn/ai/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer your_api_key_here'
  },
  body: JSON.stringify({
    model: 'deepseek-r1',
    messages: [
      {
        role: 'user',
        content: '证明费马大定理的基本思路是什么？'
      }
    ],
    temperature: 0.1, // 推理任务建议使用较低温度
    stream: true      // 可以看到思维过程
  })
});

// 处理包含推理过程的响应
// DeepSeek-R1会在reasoning_content字段中输出思维过程
上次编辑于:
贡献者: smallchill