MapleGCM API 开发文档

Authorization: Bearer sk-gcm-YOUR_SECRET_KEY

{
  "model": "GCM-Optimize",
  "type": "spoken",
  "messages": [{"role": "user", "content": "这玩意儿咋用啊"}]
}

curl https://developer.maplegcm.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-gcm-xxxxxx" \
  -d '{
    "model": "GCM-2",
    "messages": [
      {"role": "system", "content": "你是一个专业的AI助手。"},
      {"role": "user", "content": "请介绍一下你自己"}
    ],
    "stream": true
  }'

data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","created":1234567890,"model":"GCM-2","choices":[{"index":0,"delta":{"content":"你好"},"finish_reason":null}]}

data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","created":1234567890,"model":"GCM-2","choices":[{"index":0,"delta":{"content":"！"},"finish_reason":null}]}

data: [DONE]

import requests
import json

API_KEY = "sk-gcm-YOUR_KEY"
API_URL = "https://developer.maplegcm.com/v1/chat/completions"

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

data = {
    "model": "GCM-2-Search",
    "messages": [
        {"role": "user", "content": "2024年最新的AI技术突破有哪些？"}
    ],
    "stream": True
}

response = requests.post(API_URL, headers=headers, json=data, stream=True)
# ... 处理流式响应 ...

<thinking>
这里是模型对于问题的深度分析和推理过程...
1. 分析问题核心...
2. 拆解逻辑步骤...
3. 验证推导结果...
</thinking>

这里是最终的回答结果。

# 使用 GCM-2-Thinking
response = client.chat.completions.create(
    model="GCM-2-Thinking",
    messages=[
        {"role": "user", "content": "请证明费马大定理"}
    ],
    stream=True
)

{
  "object": "list",
  "data": [
    {
      "id": "GCM-2",
      "object": "model",
      "created": 1686935002,
      "owned_by": "maplegcm"
    },
    {
      "id": "GCM-2-Search",
      "object": "model",
      "created": 1699935002,
      "owned_by": "maplegcm"
    },
    {
      "id": "GCM-2-Thinking",
      "object": "model",
      "created": 1704067200,
      "owned_by": "maplegcm"
    }
  ]
}

stream = client.chat.completions.create(
    model="GCM-2",
    messages=[{"role": "user", "content": "讲个故事"}],
    stream=True
)

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

pip install requests

import requests
import json

API_KEY = "sk-gcm-YOUR_KEY"
API_URL = "https://developer.maplegcm.com/v1/chat/completions"

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

data = {
    "model": "GCM-2",
    "messages": [
        {"role": "system", "content": "你是一个专业的助手。"},
        {"role": "user", "content": "你好，请介绍一下你自己"}
    ],
    "stream": True
}

# 发起流式请求
response = requests.post(API_URL, headers=headers, json=data, stream=True)

if response.status_code == 200:
    for line in response.iter_lines():
        if line:
            line = line.decode('utf-8')
            if line.startswith("data: "):
                json_str = line[6:]  # 去掉 'data: ' 前缀
                if json_str == "[DONE]":
                    break
                try:
                    chunk = json.loads(json_str)
                    if "content" in chunk["choices"][0]["delta"]:
                        print(chunk["choices"][0]["delta"]["content"], end="", flush=True)
                except json.JSONDecodeError:
                    continue
else:
    print(f"Error: {response.status_code} - {response.text}")

const API_KEY = 'sk-gcm-YOUR_KEY';
const API_URL = 'https://developer.maplegcm.com/v1/chat/completions';

async function main() {
  const response = await fetch(API_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${API_KEY}`
    },
    body: JSON.stringify({
      model: 'GCM-2',
      messages: [{ role: 'user', content: 'Hello world' }],
      stream: true
    })
  });

  if (!response.ok) {
    console.error(`Error: ${response.status} ${response.statusText}`);
    return;
  }

  // 处理流式响应
  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 jsonStr = line.slice(6);
        if (jsonStr === '[DONE]') return;

        try {
          const data = JSON.parse(jsonStr);
          const content = data.choices[0]?.delta?.content || '';
          process.stdout.write(content);
        } catch (e) {
          // 忽略解析错误
        }
      }
    }
  }
}

main();

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

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

type ChatRequest struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
	Stream   bool      `json:"stream"`
}

type ChatResponseChunk struct {
	Choices []struct {
		Delta struct {
			Content string `json:"content"`
		} `json:"delta"`
	} `json:"choices"`
}

func main() {
	apiKey := "sk-gcm-YOUR_KEY"
	url := "https://developer.maplegcm.com/v1/chat/completions"

	reqBody, _ := json.Marshal(ChatRequest{
		Model: "GCM-2",
		Messages: []Message{
			{Role: "user", Content: "Hello!"},
		},
		Stream: true,
	})

	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(reqBody))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	defer resp.Body.Close()

	reader := bufio.NewReader(resp.Body)
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			break
		}

		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "data: ") {
			data := strings.TrimPrefix(line, "data: ")
			if data == "[DONE]" {
				break
			}

			var chunk ChatResponseChunk
			if err := json.Unmarshal([]byte(data), &chunk); err == nil {
				if len(chunk.Choices) > 0 {
					fmt.Print(chunk.Choices[0].Delta.Content)
				}
			}
		}
	}
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse.BodyHandlers;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        String apiKey = "sk-gcm-YOUR_KEY";
        String url = "https://developer.maplegcm.com/v1/chat/completions";
        
        String jsonBody = "{"
            + "\"model\": \"GCM-2\","
            + "\"messages\": [{\"role\": \"user\", \"content\": \"Hello!\"}],"
            + "\"stream\": true"
            + "}";

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

        client.sendAsync(request, BodyHandlers.ofLines())
            .thenAccept(response -> {
                response.body().forEach(line -> {
                    if (line.startsWith("data: ")) {
                        String data = line.substring(6);
                        if (!"[DONE]".equals(data)) {
                            // 简单的字符串提取，实际项目中建议使用 Jackson/Gson
                            int contentIndex = data.indexOf("\"content\":");
                            if (contentIndex != -1) {
                                int start = contentIndex + 11;
                                int end = data.indexOf("\"", start);
                                if (end != -1) {
                                    String content = data.substring(start, end);
                                    // 处理转义字符
                                    content = content.replace("\\n", "\n").replace("\\\"", "\"");
                                    System.out.print(content);
                                }
                            }
                        }
                    }
                });
            })
            .join(); // 等待完成
    }
}

{
  "error": {
    "message": "Insufficient balance",
    "type": "insufficient_balance",
    "code": 402
  }
}