curl -X POST "https://api.tokenops.ai/v1beta/models/gemini-2.5-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API-KEY>" \
  -d '{
    "contents": [
      {
        "parts": [
          {
            "text": "你好，请介绍一下你自己"
          }
        ]
      }
    ],
    "generationConfig": {
      "maxOutputTokens": 3000,
      "temperature": 0.7
    }
  }'

import requests
import json

# 配置API密钥和基础URL
API_KEY = "<API-KEY>"
BASE_URL = "https://api.tokenops.ai/v1beta"

def chat_with_gemini(message, model="gemini-2.5-flash"):
    url = f"{BASE_URL}/models/{model}:generateContent"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {API_KEY}"
    }
    
    data = {
        "contents": [
            {
                "parts": [
                    {
                        "text": message
                    }
                ]
            }
        ],
        "generationConfig": {
            "maxOutputTokens": 3000,
            "temperature": 0.7
        }
    }
    
    response = requests.post(url, headers=headers, json=data)
    
    if response.status_code == 200:
        result = response.json()
        return result['candidates'][0]['content']['parts'][0]['text']
    else:
        return f"错误: {response.status_code} - {response.text}"

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

const axios = require('axios');

// 配置API密钥和基础URL
const API_KEY = '<API-KEY>';
const BASE_URL = 'https://api.tokenops.ai/v1beta';

async function chatWithGemini(message, model = 'gemini-2.5-flash') {
    const url = `${BASE_URL}/models/${model}:generateContent`;
    
    const headers = {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
    };
    
    const data = {
        contents: [
            {
                parts: [
                    {
                        text: message
                    }
                ]
            }
        ],
        generationConfig: {
            maxOutputTokens: 3000,
            temperature: 0.7
        }
    };
    
    try {
        const response = await axios.post(url, data, { headers });
        return response.data.candidates[0].content.parts[0].text;
    } catch (error) {
        return `错误: ${error.response?.status} - ${error.response?.data || error.message}`;
    }
}

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

package main

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

const (
    APIKey  = "<API-KEY>"
    BaseURL = "https://api.tokenops.ai/v1beta"
)

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

type Content struct {
    Parts []Part `json:"parts"`
}

type GenerationConfig struct {
    MaxOutputTokens int     `json:"maxOutputTokens"`
    Temperature     float64 `json:"temperature"`
}

type GeminiRequest struct {
    Contents         []Content        `json:"contents"`
    GenerationConfig GenerationConfig `json:"generationConfig"`
}

type Candidate struct {
    Content Content `json:"content"`
}

type GeminiResponse struct {
    Candidates []Candidate `json:"candidates"`
}

func chatWithGemini(message string, model string) (string, error) {
    if model == "" {
        model = "gemini-2.5-flash"
    }
    
    url := fmt.Sprintf("%s/models/%s:generateContent", BaseURL, model)
    
    reqData := GeminiRequest{
        Contents: []Content{
            {
                Parts: []Part{
                    {
                        Text: message,
                    },
                },
            },
        },
        GenerationConfig: GenerationConfig{
            MaxOutputTokens: 3000,
            Temperature:     0.7,
        },
    }
    
    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))
    
    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 geminiResp GeminiResponse
    err = json.Unmarshal(body, &geminiResp)
    if err != nil {
        return "", err
    }
    
    return geminiResp.Candidates[0].Content.Parts[0].Text, nil
}

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

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;
import java.util.List;
import java.util.Map;

public class GeminiBasicChat {
    private static final String API_KEY = "<API-KEY>";
    private static final String BASE_URL = "https://api.tokenops.ai/v1beta";
    
    public static String chatWithGemini(String message, String model) throws IOException, InterruptedException {
        if (model == null || model.isEmpty()) {
            model = "gemini-2.5-flash";
        }
        
        HttpClient client = HttpClient.newHttpClient();
        ObjectMapper mapper = new ObjectMapper();
        
        Map<String, Object> request = Map.of(
            "contents", List.of(
                Map.of("parts", List.of(
                    Map.of("text", message)
                ))
            ),
            "generationConfig", Map.of(
                "maxOutputTokens", 3000,
                "temperature", 0.7
            )
        );
        
        String jsonBody = mapper.writeValueAsString(request);
        
        HttpRequest httpRequest = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/models/" + model + ":generateContent"))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer " + API_KEY)
            .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("candidates").get(0)
                .get("content").get("parts").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 = chatWithGemini(message, "gemini-2.5-flash");
            System.out.println("Gemini回复: " + reply);
        } catch (Exception e) {
            System.err.println("错误: " + e.getMessage());
        }
    }
}

<?php

class GeminiBasicChat {
    private $apiKey;
    private $baseUrl;
    
    public function __construct($apiKey, $baseUrl = 'https://api.tokenops.ai/v1beta') {
        $this->apiKey = $apiKey;
        $this->baseUrl = $baseUrl;
    }
    
    public function chatWithGemini($message, $model = 'gemini-2.5-flash') {
        $url = $this->baseUrl . '/models/' . $model . ':generateContent';
        
        $data = [
            'contents' => [
                [
                    'parts' => [
                        [
                            'text' => $message
                        ]
                    ]
                ]
            ],
            'generationConfig' => [
                'maxOutputTokens' => 3000,
                'temperature' => 0.7
            ]
        ];
        
        $options = [
            'http' => [
                'header' => [
                    'Content-Type: application/json',
                    'Authorization: Bearer ' . $this->apiKey
                ],
                '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['candidates'][0]['content']['parts'][0]['text'])) {
            return $responseData['candidates'][0]['content']['parts'][0]['text'];
        } else {
            return '解析响应失败: ' . $response;
        }
    }
}

// 使用示例
$apiKey = '<API-KEY>';
$chat = new GeminiBasicChat($apiKey);

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

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

?>