一把 API Key，
调用 GPT、Claude、Gemini
与国产模型

from openai import OpenAIclient = OpenAI(base_url="https://www.vibeapi.cn/v1", api_key="YOUR_API_KEY")stream = client.responses.create(    model="gpt-6-astra",    input="用一句话解释什么是幂等。",    stream=True,)for event in stream:    if event.type == "response.output_text.delta":        print(event.delta, end="", flush=True)

import OpenAI from "openai";const client = new OpenAI({ baseURL: "https://www.vibeapi.cn/v1", apiKey: "YOUR_API_KEY" });const stream = await client.responses.create({  model: "gpt-6-astra",  input: "用一句话解释什么是幂等。",  stream: true,});for await (const event of stream) {  if (event.type === "response.output_text.delta")    process.stdout.write(event.delta);}

import (    "context"    "fmt"    "github.com/openai/openai-go/v3"    "github.com/openai/openai-go/v3/option"    "github.com/openai/openai-go/v3/responses")client := openai.NewClient(    option.WithAPIKey("YOUR_API_KEY"),    option.WithBaseURL("https://www.vibeapi.cn/v1"),)stream := client.Responses.NewStreaming(context.Background(), responses.ResponseNewParams{    Model: "gpt-6-astra",    Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("用一句话解释什么是幂等。")},})for stream.Next() {    ev := stream.Current()    if ev.Type == "response.output_text.delta" {        fmt.Print(ev.Delta)    }}

import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.core.http.StreamResponse;import com.openai.models.responses.ResponseCreateParams;import com.openai.models.responses.ResponseStreamEvent;OpenAIClient client = OpenAIOkHttpClient.builder()    .apiKey("YOUR_API_KEY")    .baseUrl("https://www.vibeapi.cn/v1")    .build();ResponseCreateParams params = ResponseCreateParams.builder()    .model("gpt-6-astra")    .input("用一句话解释什么是幂等。")    .build();try (StreamResponse<ResponseStreamEvent> stream = client.responses().createStreaming(params)) {    stream.stream().forEach(event ->        event.outputTextDelta().ifPresent(d -> System.out.print(d.delta())));}

using System.ClientModel;using OpenAI.Responses;#pragma warning disable OPENAI001ResponsesClient client = new(    new ApiKeyCredential("YOUR_API_KEY"),    new ResponsesClientOptions { Endpoint = new Uri("https://www.vibeapi.cn/v1") });await foreach (StreamingResponseUpdate update in    client.CreateResponseStreamingAsync("gpt-6-astra", "用一句话解释什么是幂等。")){    if (update is StreamingResponseOutputTextDeltaUpdate delta)        Console.Write(delta.Delta);}

require "openai"client = OpenAI::Client.new(api_key: "YOUR_API_KEY", base_url: "https://www.vibeapi.cn/v1")stream = client.responses.stream(  model: "gpt-6-astra",  input: "用一句话解释什么是幂等。")stream.each do |event|  print(event.delta) if event.type == :"response.output_text.delta"end

curl -N https://www.vibeapi.cn/v1/responses \  -H "Authorization: Bearer $API_KEY" \  -H "Content-Type: application/json" \  -d '{    "model": "gpt-6-astra",    "input": "用一句话解释什么是幂等。",    "stream": true  }'

from openai import OpenAIclient = OpenAI(base_url="https://www.vibeapi.cn/v1", api_key="YOUR_API_KEY")stream = client.chat.completions.create(    model="deepseek-v4-pro",    messages=[{"role": "user", "content": "用一句话解释什么是幂等。"}],    stream=True,)for chunk in stream:    delta = chunk.choices[0].delta.content    if delta:        print(delta, end="", flush=True)

import OpenAI from "openai";const client = new OpenAI({ baseURL: "https://www.vibeapi.cn/v1", apiKey: "YOUR_API_KEY" });const stream = await client.chat.completions.create({  model: "deepseek-v4-pro",  messages: [{ role: "user", content: "用一句话解释什么是幂等。" }],  stream: true,});for await (const chunk of stream) {  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");}

import (    "context"    "fmt"    "github.com/openai/openai-go/v3"    "github.com/openai/openai-go/v3/option")client := openai.NewClient(    option.WithAPIKey("YOUR_API_KEY"),    option.WithBaseURL("https://www.vibeapi.cn/v1"),)stream := client.Chat.Completions.NewStreaming(context.Background(), openai.ChatCompletionNewParams{    Model:    "deepseek-v4-pro",    Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage("用一句话解释什么是幂等。")},})for stream.Next() {    if c := stream.Current().Choices; len(c) > 0 {        fmt.Print(c[0].Delta.Content)    }}

import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.chat.completions.ChatCompletionChunk;import com.openai.models.chat.completions.ChatCompletionCreateParams;OpenAIClient client = OpenAIOkHttpClient.builder()    .apiKey("YOUR_API_KEY")    .baseUrl("https://www.vibeapi.cn/v1")    .build();ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()    .model("deepseek-v4-pro")    .addUserMessage("用一句话解释什么是幂等。")    .build();try (var stream = client.chat().completions().createStreaming(params)) {    stream.stream()        .flatMap(chunk -> chunk.choices().stream())        .flatMap(choice -> choice.delta().content().stream())        .forEach(System.out::print);}

using System.ClientModel;using OpenAI;using OpenAI.Chat;ChatClient client = new(    "deepseek-v4-pro",    new ApiKeyCredential("YOUR_API_KEY"),    new OpenAIClientOptions { Endpoint = new Uri("https://www.vibeapi.cn/v1") });await foreach (StreamingChatCompletionUpdate update in    client.CompleteChatStreamingAsync([new UserChatMessage("用一句话解释什么是幂等。")])){    foreach (ChatMessageContentPart part in update.ContentUpdate)        Console.Write(part.Text);}

require "openai"client = OpenAI::Client.new(api_key: "YOUR_API_KEY", base_url: "https://www.vibeapi.cn/v1")stream = client.chat.completions.stream(  model: "deepseek-v4-pro",  messages: [{ role: :user, content: "用一句话解释什么是幂等。" }])stream.text.each { |text| print(text) }

curl -N https://www.vibeapi.cn/v1/chat/completions \  -H "Authorization: Bearer $API_KEY" \  -H "Content-Type: application/json" \  -d '{    "model": "deepseek-v4-pro",    "messages": [{"role": "user", "content": "用一句话解释什么是幂等。"}],    "stream": true  }'

import anthropicclient = anthropic.Anthropic(base_url="https://www.vibeapi.cn", api_key="YOUR_API_KEY")with client.messages.stream(    model="claude-opus-5",    max_tokens=1024,    messages=[{"role": "user", "content": "用一句话解释什么是幂等。"}],) as stream:    for text in stream.text_stream:        print(text, end="", flush=True)

import Anthropic from "@anthropic-ai/sdk";const client = new Anthropic({ baseURL: "https://www.vibeapi.cn", apiKey: "YOUR_API_KEY" });const stream = await client.messages.create({  model: "claude-opus-5",  max_tokens: 1024,  messages: [{ role: "user", content: "用一句话解释什么是幂等。" }],  stream: true,});for await (const event of stream) {  if (event.type === "content_block_delta" && event.delta.type === "text_delta")    process.stdout.write(event.delta.text);}

import (    "context"    "fmt"    "github.com/anthropics/anthropic-sdk-go"    "github.com/anthropics/anthropic-sdk-go/option")client := anthropic.NewClient(    option.WithAPIKey("YOUR_API_KEY"),    option.WithBaseURL("https://www.vibeapi.cn"),)stream := client.Messages.NewStreaming(context.Background(), anthropic.MessageNewParams{    Model:     "claude-opus-5",    MaxTokens: 1024,    Messages:  []anthropic.MessageParam{anthropic.NewUserMessage(anthropic.NewTextBlock("用一句话解释什么是幂等。"))},})for stream.Next() {    if ev, ok := stream.Current().AsAny().(anthropic.ContentBlockDeltaEvent); ok {        if d, ok := ev.Delta.AsAny().(anthropic.TextDelta); ok {            fmt.Print(d.Text)        }    }}

import com.anthropic.client.AnthropicClient;import com.anthropic.client.okhttp.AnthropicOkHttpClient;import com.anthropic.models.messages.MessageCreateParams;AnthropicClient client = AnthropicOkHttpClient.builder()    .apiKey("YOUR_API_KEY")    .baseUrl("https://www.vibeapi.cn")    .build();MessageCreateParams params = MessageCreateParams.builder()    .model("claude-opus-5")    .maxTokens(1024L)    .addUserMessage("用一句话解释什么是幂等。")    .build();try (var stream = client.messages().createStreaming(params)) {    stream.stream().forEach(event ->        event.contentBlockDelta().ifPresent(d ->            d.delta().text().ifPresent(t -> System.out.print(t.text()))));}

using Anthropic;AnthropicClient client = new() { ApiKey = "YOUR_API_KEY", BaseUrl = "https://www.vibeapi.cn" };var parameters = new MessageCreateParams{    Model = "claude-opus-5",    MaxTokens = 1024,    Messages = [new() { Role = Role.User, Content = "用一句话解释什么是幂等。" }]};// 每个流式事件一个对象，文本在 content_block_delta 事件的 delta.text 里await foreach (var evt in client.Messages.CreateStreaming(parameters)){    Console.WriteLine(evt);}

require "anthropic"client = Anthropic::Client.new(api_key: "YOUR_API_KEY", base_url: "https://www.vibeapi.cn")stream = client.messages.stream(  model: "claude-opus-5",  max_tokens: 1024,  messages: [{ role: "user", content: "用一句话解释什么是幂等。" }])stream.text.each { |text| print(text) }

use Anthropic\Client;$client = new Client(apiKey: 'YOUR_API_KEY', baseUrl: 'https://www.vibeapi.cn');$stream = $client->messages->createStream(    model: 'claude-opus-5',    maxTokens: 1024,    messages: [['role' => 'user', 'content' => '用一句话解释什么是幂等。']],);foreach ($stream as $event) {    if ($event->type === 'content_block_delta' && $event->delta->type === 'text_delta') {        echo $event->delta->text;    }}

curl -N https://www.vibeapi.cn/v1/messages \  -H "Authorization: Bearer $API_KEY" \  -H "anthropic-version: 2023-06-01" \  -H "Content-Type: application/json" \  -d '{    "model": "claude-opus-5",    "max_tokens": 1024,    "messages": [{"role": "user", "content": "用一句话解释什么是幂等。"}],    "stream": true  }'

from google import genaifrom google.genai import typesclient = genai.Client(    api_key="YOUR_API_KEY",    http_options=types.HttpOptions(base_url="https://www.vibeapi.cn"),)for chunk in client.models.generate_content_stream(    model="gemini-3.8-flash",    contents="用一句话解释什么是幂等。",):    if chunk.text:        print(chunk.text, end="", flush=True)

import { GoogleGenAI } from "@google/genai";const ai = new GoogleGenAI({  apiKey: "YOUR_API_KEY",  httpOptions: { baseUrl: "https://www.vibeapi.cn" },});const stream = await ai.models.generateContentStream({  model: "gemini-3.8-flash",  contents: "用一句话解释什么是幂等。",});for await (const chunk of stream) {  if (chunk.text) process.stdout.write(chunk.text);}

import (    "context"    "fmt"    "google.golang.org/genai")ctx := context.Background()client, _ := genai.NewClient(ctx, &genai.ClientConfig{    APIKey:      "YOUR_API_KEY",    HTTPOptions: genai.HTTPOptions{BaseURL: "https://www.vibeapi.cn"},})stream := client.Models.GenerateContentStream(ctx, "gemini-3.8-flash", genai.Text("用一句话解释什么是幂等。"), nil)for chunk, _ := range stream {    fmt.Print(chunk.Text())}

import com.google.genai.Client;import com.google.genai.ResponseStream;import com.google.genai.types.GenerateContentResponse;import com.google.genai.types.HttpOptions;Client client = Client.builder()    .apiKey("YOUR_API_KEY")    .httpOptions(HttpOptions.builder().baseUrl("https://www.vibeapi.cn").build())    .build();try (ResponseStream<GenerateContentResponse> stream =         client.models.generateContentStream("gemini-3.8-flash", "用一句话解释什么是幂等。", null)) {    for (GenerateContentResponse res : stream) {        System.out.print(res.text());    }}

curl -N "https://www.vibeapi.cn/v1beta/models/gemini-3.8-flash:streamGenerateContent" \  -H "Authorization: Bearer $API_KEY" \  -H "Content-Type: application/json" \  -d '{    "contents": [{"role": "user", "parts": [{"text": "用一句话解释什么是幂等。"}]}]  }'