Modo ultrarrápido
Modo ultrarrápidoEl modo ultrarrápido es el nivel de servicio más rápido de la API de OpenAI. Está disponible de forma general para GPT-6 Astra y GPT-6.1 Sol. Úsalo cuando la velocidad justifique el costo adicional.
Recomendamos enfáticamente usar WebSockets, sobre todo en aplicaciones con agentes que hacen muchas llamadas a herramientas en poco tiempo. Sin una conexión persistente, la sobrecarga de red puede limitar la reducción de la latencia.
El modo ultrarrápido de GPT-6 Astra y GPT-6.1 Sol está disponible para todos los usuarios de la API.
Sus límites de solicitudes son independientes de los de los modos estándar y rápido. Consulta los
límites de tu organización antes de aumentar el tráfico. Si tu organización trabaja con un equipo
de cuentas de OpenAI, comunícate con ese equipo para solicitar límites de solicitudes más altos.
Asigna a model el valor gpt-6-astra o gpt-6.1-sol y a service_tier el valor ultrafast en cada evento response.create.
Instala el SDK y las dependencias de WebSocket para tu lenguaje siguiendo los pasos de Conéctate y crea respuestas. Configura OPENAI_API_KEY en tu entorno antes de ejecutar el ejemplo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53// Install: npm install openai ws
// Set OPENAI_API_KEY in your environment.
import OpenAI from "openai";
import { ResponsesWS } from "openai/resources/responses/ws";
const client = new OpenAI();
const ws = new ResponsesWS(client);
let previousResponseId = null;
try {
for (const input of [
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.",
]) {
let completed = false;
const events = ws.stream();
ws.send({
type: "response.create",
model: "gpt-6-astra",
service_tier: "ultrafast",
previous_response_id: previousResponseId,
input,
});
for await (const event of events) {
if (event.type === "error") throw event.error;
if (event.type !== "message") continue;
const message = event.message;
if (message.type === "response.output_text.delta") {
process.stdout.write(message.delta);
} else if (message.type === "response.completed") {
previousResponseId = message.response.id;
completed = true;
console.log();
break;
} else if (
message.type === "response.failed" ||
message.type === "response.incomplete"
) {
throw new Error(JSON.stringify(message));
}
}
if (!completed) {
throw new Error("Connection closed before the response finished.");
}
}
} finally {
ws.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34# Install: pip install --upgrade "openai[realtime]"
# Set OPENAI_API_KEY in your environment.
from openai import OpenAI
client = OpenAI()
previous_response_id: str | None = None
prompts = [
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.",
]
with client.responses.connect() as connection:
for prompt in prompts:
connection.response.create(
model="gpt-6-astra",
service_tier="ultrafast",
store=False, # Keep this conversation on the current connection.
previous_response_id=previous_response_id,
input=prompt,
)
for event in connection:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
elif event.type == "response.completed":
previous_response_id = event.response.id
print()
break
elif event.type in {"response.failed", "response.incomplete", "error"}:
raise RuntimeError(event.to_json())
else:
raise RuntimeError("Connection closed before the response finished.")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56package main
import (
"context"
"fmt"
"time"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
client := openai.NewClient()
conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})
if err != nil {
panic(err)
}
defer conn.Close()
previousResponseID := ""
for _, prompt := range []string{
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.",
} {
request := responses.ResponsesClientEventResponseCreateParam{
Model: "gpt-6-astra",
ServiceTier: "ultrafast",
Input: responses.ResponsesClientEventResponseCreateInputUnionParam{
OfString: openai.String(prompt),
},
}
if previousResponseID != "" {
request.PreviousResponseID = openai.String(previousResponseID)
}
if err := conn.Create(ctx, request); err != nil {
panic(err)
}
// FinalResponse reads events until the response finishes.
response, err := conn.FinalResponse(ctx)
if err != nil {
panic(err)
}
if response.Status != responses.ResponseStatusCompleted {
panic(fmt.Sprintf("Response ended with status %s", response.Status))
}
previousResponseID = response.ID
fmt.Println(response.OutputText())
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseStatus;
import com.openai.models.responses.ResponsesClientEvent;
import java.util.List;
var client = OpenAIOkHttpClient.fromEnv();
try (var connection = client.responses().connect()) {
String previousResponseId = null;
for (var prompt :
List.of(
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.")) {
var request =
ResponsesClientEvent.ResponseCreate.builder()
.model("gpt-6-astra")
.serviceTier(ResponsesClientEvent.ResponseCreate.ServiceTier.ULTRAFAST)
.input(prompt);
if (previousResponseId != null) {
request.previousResponseId(previousResponseId);
}
connection.send(ResponsesClientEvent.ofResponseCreate(request.build()));
var response = connection.finalResponse();
if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
throw new IllegalStateException(
"Response ended with status " + response.status().orElse(null));
}
previousResponseId = response.id();
response.output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
}
} finally {
client.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41# Install: gem install openai async-websocket
# Set OPENAI_API_KEY in your environment.
require "async"
require "openai"
client = OpenAI::Client.new
request = {
model: "gpt-6-astra",
service_tier: :ultrafast
}
prompts = [
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red."
]
Sync do |task|
task.with_timeout(120) do
client.responses.connect(request_options: { timeout: 10 }) do |connection|
prompts.each do |prompt|
connection.response.create(**request, input: prompt)
loop do
event = connection.receive
raise "Connection closed before the response finished" unless event
case event
when OpenAI::Responses::ResponseCompletedEvent
request[:previous_response_id] = event.response.id
puts(event.response.output_text)
break
when OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponseIncompleteEvent,
OpenAI::Responses::ResponsesServerEvent::ResponseWsError
raise "Response failed: #{event.to_json}"
end
end
end
end
end
end
Los ejemplos envían dos solicitudes por la misma conexión e imprimen cada respuesta. Los ejemplos de Go, Java y Ruby esperan a recibir la respuesta completa antes de imprimirla. La segunda solicitud envía el nuevo prompt y pasa el ID de la primera respuesta como previous_response_id. Reutiliza la conexión para los turnos posteriores y para enviar los resultados de las herramientas. Consulta Continúa con entradas incrementales.
El modo ultrarrápido también admite solicitudes HTTP mediante el SDK. En aplicaciones con agentes que llaman a herramientas con frecuencia, usa una conexión WebSocket persistente para reducir la sobrecarga entre solicitudes.
1
2
3
4
5
6
7
8
9
10
11import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6-astra",
service_tier: "ultrafast",
input: "Explain why the sky is blue in one sentence.",
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
input="Explain why the sky is blue in one sentence.",
service_tier="ultrafast",
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
ServiceTier: responses.ResponseNewParamsServiceTierUltrafast,
Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain why the sky is blue in one sentence.")},
})
if err != nil {
panic(err)
}
fmt.Println(response.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input("Explain why the sky is blue in one sentence.")
.serviceTier(ResponseCreateParams.ServiceTier.ULTRAFAST)
.build();
client.responses().create(params).output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11require "openai"
client = OpenAI::Client.new
response = client.responses.create(
model: "gpt-6-astra",
service_tier: :ultrafast,
input: "Explain why the sky is blue in one sentence."
)
puts(response.output_text)
1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6-astra",
"input": "Explain why the sky is blue in one sentence.",
"service_tier": "ultrafast"
}'
Este ejemplo espera a recibir la respuesta completa. Para mostrar la salida a medida que llega, habilita el streaming.
En el modo ultrarrápido, GPT-6.1 Sol tiene los siguientes límites predeterminados de tokens por minuto:
| Nivel de uso de la API |
Tokens por minuto (TPM) |
| Build |
1 000 000 |
| Launch |
4 000 000 |
| Grow |
40 000 000 |
En el modo ultrarrápido, GPT-6 Astra tiene los siguientes límites predeterminados de tokens por minuto:
| Nivel de uso de la API |
Tokens por minuto (TPM) |
| Build |
500 000 |
| Launch |
1 000 000 |
| Grow |
5 000 000 |
Consulta la tabla de precios del modo ultrarrápido para ver los precios de entrada, entrada en caché, escritura en caché y salida.
El modo ultrarrápido de GPT-6.1 Sol admite la residencia de datos en Estados Unidos y en la Unión Europea, así como el procesamiento global. El modo ultrarrápido de GPT-6 Astra solo admite la residencia de datos en Estados Unidos y el procesamiento global.
