ShareAI
AI Prosumer
FR
Langue
Z.ai

glm4

Obtenir une clé API
z-ai/glm4:latest

Un modèle linguistique général multilingue performant avec des résultats compétitifs par rapport à Llama 3.

Entrée → Sortie
Texte Texte
Entrée / Sortie · par 1M tokens
Non disponible dans les Crédits
Fenêtre de contexte
131 072 jetons
Licence: ouvrir_poids

Du modèle à l'application

Démarrage rapide

Référence API

  1. Obtenez votre clé API

    Créez une clé dans la Console ShareAI, puis enregistrez-la comme variable d'environnement sur votre serveur.

    Créer une clé API
    Variable d'environnement
    export SHAREAI_API_KEY="your-api-key"

  2. Choisissez votre point de terminaison

    Envoyez une requête POST avec votre clé API dans l'en-tête Authorization.

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

    Le point de terminaison de ce tag n’a pas été confirmé. Consultez la référence API et votre Console avant d’envoyer une requête.

  3. Faites votre première requête

    Les exemples utilisent votre tag sélectionné et montrent son format de requête. Exécutez-les sur votre serveur pour garder votre clé API privée. La disponibilité des modèles et l'accès au compte sont vérifiés lorsque vous envoyez une requête.

    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": "z-ai/glm4:latest",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}'
    Python
    import json
import os
import urllib.request

payload = {
    "model": "z-ai/glm4:latest",
    "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": "z-ai/glm4:latest",
  "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)
}

    Enregistrez sous main.go et exécutez go run main.go. Cet exemple utilise la bibliothèque standard Go.

    Configurez les dépendances Rust

    Dans votre projet Cargo, ajoutez ces dépendances. Enregistrez l'exemple sous src/main.rs, puis exécutez cargo run.

    Commandes Cargo
    cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
cargo add serde_json@1
    Rouille
    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": "z-ai/glm4:latest",
  "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": "z-ai/glm4:latest",
  "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));

Tarification

Pas d'offre de Crédits pour ce tag

Choisissez un autre tag de Crédits ou explorez l'Échange de Tokens dans le Réseau.

Explorer le Réseau →

Un peu plus de détails

Questions fréquemment posées

Qu'est-ce que glm4 ?

Un modèle linguistique général multilingue performant avec des résultats compétitifs par rapport à Llama 3.

Combien coûte glm4 ?

Un prix par jeton n'a pas été publié pour cette étiquette. Consultez votre Console pour connaître les accès disponibles et les tarifs actuels.

Quels sont les entrées et sorties prises en charge par glm4 ?

Entrées : Texte. Sorties : Texte. Ces capacités s'appliquent au modèle sélectionné. Consultez la documentation de l'endpoint pour les formats de requête pris en charge.

Quelle est la longueur de contexte de glm4 ?

Ce tag dispose d'une fenêtre de contexte de 131 072 tokens. La taille du contexte et les seuils de tarification sont distincts. Les limites de requêtes peuvent être inférieures pour un déploiement particulier.

Comment utiliser glm4 avec ShareAI ?

Créez une clé API dans la Console ShareAI, choisissez une étiquette de modèle, et envoyez une requête authentifiée à l'endpoint dans le guide de démarrage rapide. Votre clé doit avoir accès au modèle choisi. Conservez votre clé sur votre serveur.