ShareAI
AI Prosumer
RO
Limbă
OpenAI

gpt-oss-120b

Obține cheia API
openai/gpt-oss-120b

gpt-oss-120b este un model creat de OpenAI care acceptă text și produce text. Această intrare din catalog identifică openai/gpt-oss-120b. Fereastra de context revizuită este de 131.072 de tokeni; limitele de implementare pot fi mai mici.

Intrare → Ieșire
Text Text
Acces
Schimb de Token-uri
Fereastră de context
131.072 tokeni
Randament maxim
131.072 tokeni
Licență: sursă_deschisă

De la model la aplicație

Start rapid

Referință API

  1. Obține cheia ta API

    Creează o cheie în Consola ShareAI, apoi salveaz-o ca variabilă de mediu pe serverul tău.

    Creează cheie API
    Variabilă de mediu
    export SHAREAI_API_KEY="your-api-key"

  2. Alege punctul tău final

    Trimite un request POST cu cheia ta API în antetul Authorization.

    POSThttps://api.shareai.now/api/v1/chat/completions

    Endpointul acestui tag nu a fost confirmat. Verifică referința API și Consola ta înainte de a trimite o cerere.

  3. Fă primul tău request

    Exemplele folosesc eticheta selectată de tine și arată formatul cererii. Rulează-le pe serverul tău pentru a păstra cheia API privată. Disponibilitatea modelului și accesul la cont sunt verificate când trimiți o cerere.

    cURL
    curl --fail-with-body --request POST 'https://api.shareai.now/api/v1/chat/completions' \
  --header "Authorization: Bearer ${SHAREAI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}'
    Python
    import json
import os
import urllib.request

payload = {
    "model": "openai/gpt-oss-120b",
    "messages": [
        {
            "role": "user",
            "content": "Hello!",
        },
    ],
    "stream": False,
}
request = urllib.request.Request("https://api.shareai.now/api/v1/chat/completions",
    data=json.dumps(payload).encode(),
    headers={
        "Authorization": f"Bearer {os.environ['SHAREAI_API_KEY']}",
        "Content-Type": "application/json",
    },
    method="POST",
)
with urllib.request.urlopen(request, timeout=180) as response:
    print(json.dumps(json.load(response), indent=2))
    Go
    package main

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

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func run() error {
    key := os.Getenv("SHAREAI_API_KEY")
    if key == "" { return fmt.Errorf("set SHAREAI_API_KEY") }
    body := []byte(`{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}`)
    request, err := http.NewRequest(http.MethodPost, "https://api.shareai.now/api/v1/chat/completions", bytes.NewReader(body))
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + key)
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{Timeout: 180 * time.Second}
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        detail, _ := io.ReadAll(io.LimitReader(response.Body, 1<<20))
        return fmt.Errorf("ShareAI HTTP %d: %s", response.StatusCode, detail)
    }
    var result any
    if err := json.NewDecoder(response.Body).Decode(&result); err != nil { return err }
    encoder := json.NewEncoder(os.Stdout)
    encoder.SetIndent("", "  ")
    return encoder.Encode(result)
}

    Salvează ca main.go și rulează go run main.go. Acest exemplu folosește biblioteca standard Go.

    Configurează dependențele Rust

    În proiectul tău Cargo, adaugă aceste dependențe. Salvează exemplul ca src/main.rs, apoi rulează cargo run.

    Comenzi Cargo
    cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
cargo add serde_json@1
    Rugina
    fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("SHAREAI_API_KEY")?;
    let payload: serde_json::Value = serde_json::from_str(r#"{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}"#)?;
    let client = reqwest::blocking::Client::builder()
        .timeout(std::time::Duration::from_secs(180))
        .build()?;
    let response = client.post(r#"https://api.shareai.now/api/v1/chat/completions"#)
        .bearer_auth(api_key)
        .json(&payload)
        .send()?
        .error_for_status()?;
    let result: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&result)?);
    Ok(())
}
    TypeScript
    const payload = {
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
};
const response = await fetch("https://api.shareai.now/api/v1/chat/completions", {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHAREAI_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload),
});
if (!response.ok) throw new Error(await response.text());
console.log(JSON.stringify(await response.json(), null, 2));

Schimb de Token-uri

Disponibil prin Schimb de Token-uri

Utilizează rețeaua cu soldul tău de token-uri. Setările de consum ale contului tău determină modul în care sunt facturate cererile.

Un pic mai multe detalii

Întrebări frecvente

Ce este gpt-oss-120b?

gpt-oss-120b este un model creat de OpenAI care acceptă text și produce text. Această intrare din catalog identifică openai/gpt-oss-120b. Fereastra de context revizuită este de 131.072 de tokeni; limitele de implementare pot fi mai mici.

Cât costă gpt-oss-120b?

Acest tag este disponibil prin Token Exchange. Soldul tău de tokenuri și setările de consum ale contului determină accesul și facturarea. Verifică Consola pentru soldul și eligibilitatea ta.

Ce tipuri de input și output acceptă gpt-oss-120b?

Intrări: Text. Ieșiri: Text. Aceste capabilități se aplică etichetei modelului selectat. Verifică documentația endpoint-ului pentru formatele de cerere acceptate.

Care este lungimea contextului pentru gpt-oss-120b?

Acest tag are o fereastră de context de 131.072 tokeni. Dimensiunea contextului și pragurile de preț sunt separate. Limitele de cerere pot fi mai mici pentru o anumită implementare. Output maxim: 131.072 tokeni.

gpt-oss-120b acceptă apeluri de instrumente și output-uri structurate?

Apelare de unelte: Suportată. Outputuri structurate: Suportate.

Cum folosesc gpt-oss-120b cu ShareAI?

Creează o cheie API în Consola ShareAI, alege un tag de model și trimite o cerere autentificată către endpoint-ul din Quick Start. Cheia ta trebuie să aibă acces la modelul ales. Păstrează cheia pe serverul tău.