codegeex4

1. Holen Sie sich Ihren API-Schlüssel

   Erstellen Sie einen Schlüssel in der ShareAI-Konsole und speichern Sie ihn dann als Umgebungsvariable auf Ihrem Server.

   API-Schlüssel erstellen↗
   Umgebungsvariable

   export SHAREAI_API_KEY="your-api-key"

2. Wählen Sie Ihren Endpunkt

   Senden Sie eine POST-Anfrage mit Ihrem API-Schlüssel im Authorization-Header.

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

   Der Endpunkt dieses Tags wurde nicht bestätigt. Überprüfen Sie die API-Referenz und Ihre Konsole, bevor Sie eine Anfrage senden.

3. Stellen Sie Ihre erste Anfrage

   Die Beispiele verwenden dein ausgewähltes Tag und zeigen dessen Anforderungsformat. Führe sie auf deinem Server aus, um deinen API-Schlüssel privat zu halten. Die Verfügbarkeit des Modells und der Kontozugriff werden überprüft, wenn du eine Anfrage sendest.

   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/codegeex4:9b-all-q4_1",
     "messages": [
       {
         "role": "user",
         "content": "Hello!"
       }
     ],
     "stream": false
   }'

   Python

   import json
   import os
   import urllib.request
   
   payload = {
       "model": "z-ai/codegeex4:9b-all-q4_1",
       "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/codegeex4:9b-all-q4_1",
     "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)
   }

   Speichere als main.go und führe go run main.go aus. Dieses Beispiel verwendet die Go-Standardbibliothek.

   Rust-Abhängigkeiten einrichten

   Füge in deinem Cargo-Projekt diese Abhängigkeiten hinzu. Speichere das Beispiel als src/main.rs und führe dann cargo run aus.

   Cargo-Befehle

   cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
   cargo add serde_json@1

   Rost

   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/codegeex4:9b-all-q4_1",
     "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/codegeex4:9b-all-q4_1",
     "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));

Öffnen Sie einen Tag, um dessen Spezifikationen und API-Beispiele zu sehen.