AI Prosumer
EN
sentence-transformers/paraphrase-multilingual:latest

Sentence-transformers model that can be used for tasks like clustering or semantic search.

Input → Output
Text Embeddings
Access
Token Exchange
Context window
512 tokens
Model tags
3 versions available
License: open_source

From model to application

Quick Start

API reference
  1. Get your API key

    Create a key in the ShareAI Console, then save it as an environment variable on your server.

    Create API key
    Environment variable
    export SHAREAI_API_KEY="your-api-key"
  2. Choose your endpoint

    Send a POST request with your API key in the Authorization header.

    POSThttps://api.shareai.now/api/v1/embeddings
  3. Make your first request

    The examples use your selected tag and show its request format. Run them on your server to keep your API key private. Model availability and account access are checked when you send a request.

    cURL
    curl --fail-with-body --request POST 'https://api.shareai.now/api/v1/embeddings' \
      --header "Authorization: Bearer ${SHAREAI_API_KEY}" \
      --header 'Content-Type: application/json' \
      --data-raw '{
      "model": "sentence-transformers/paraphrase-multilingual:latest",
      "input": "Hello!"
    }'
    Python
    import json
    import os
    import urllib.request
    
    payload = {
        "model": "sentence-transformers/paraphrase-multilingual:latest",
        "input": "Hello!",
    }
    request = urllib.request.Request("https://api.shareai.now/api/v1/embeddings",
        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": "sentence-transformers/paraphrase-multilingual:latest",
      "input": "Hello!"
    }`)
        request, err := http.NewRequest(http.MethodPost, "https://api.shareai.now/api/v1/embeddings", 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)
    }

    Save as main.go and run go run main.go. This example uses the Go standard library.

    Set up Rust dependencies

    In your Cargo project, add these dependencies. Save the example as src/main.rs, then run cargo run.

    Cargo commands
    cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
    cargo add serde_json@1
    Rust
    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": "sentence-transformers/paraphrase-multilingual:latest",
      "input": "Hello!"
    }"#)?;
        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/embeddings"#)
            .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": "sentence-transformers/paraphrase-multilingual:latest",
      "input": "Hello!"
    };
    const response = await fetch("https://api.shareai.now/api/v1/embeddings", {
      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));

Token Exchange

Available through Token Exchange

Use the network with your token balance. Your account’s consumption settings determine how requests are billed.

Choose your version

Tags 3

Open a tag to see its specifications and API examples.

A little more detail

Frequently asked questions

What is paraphrase-multilingual?

Sentence-transformers model that can be used for tasks like clustering or semantic search.

How much does paraphrase-multilingual cost?

This tag is available through Token Exchange. Your token balance and account consumption settings determine access and billing. Check your Console for your balance and eligibility.

What inputs and outputs does paraphrase-multilingual support?

Inputs: Text. Outputs: Embeddings. These capabilities apply to the selected model tag. Check the endpoint documentation for supported request formats.

What is the context length of paraphrase-multilingual?

This tag has a context window of 512 tokens. Context size and pricing thresholds are separate. Request limits can be lower for a particular deployment.

How do I use paraphrase-multilingual with ShareAI?

Create an API key in the ShareAI Console, choose a model tag, and send an authenticated request to the endpoint in Quick Start. Your key must have access to the chosen model. Keep your key on your server.