> ## Documentation Index
> Fetch the complete documentation index at: https://phaseo.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# प्रदाताओं को कीमत, लेटेंसी या थ्रूपुट के आधार पर क्रमबद्ध करें

> किसी मॉडल के लिए सबसे सस्ता, तेज़ या सबसे अधिक थ्रूपुट वाला रूट चुनने के लिए अनुरोध-स्तरीय प्रदाता सॉर्टिंग का उपयोग करें।

जब मॉडल वही रखना हो, लेकिन किसी एक अनुरोध के लिए गेटवे से प्रदाता ऑफ़र अलग क्रम में रैंक कराने हों, तब यह रेसिपी उपयोग करें।

## लक्ष्य

* किसी अनुरोध के लिए सबसे सस्ते प्रदाता को प्राथमिकता दें।
* इंटरैक्टिव पाथ के लिए सबसे कम लेटेंसी वाले प्रदाता को प्राथमिकता दें।
* बल्क जनरेशन के लिए सबसे अधिक थ्रूपुट वाले प्रदाता को प्राथमिकता दें।

## 1. अनुरोध में `provider.sort` जोड़ें

टेक्स्ट अनुरोधों के लिए, इच्छित सॉर्ट सीधे `provider` ऑब्जेक्ट पर सेट करें।

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.phaseo.app/v1/responses \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "google/gemini-3.1-flash-lite",
      "input": "Give me one release-note bullet for the last deploy.",
      "provider": {
        "sort": "price"
      }
    }'
  ```

  ```typescript TypeScript SDK theme={null}
  import Phaseo from "@phaseo/sdk";

  const client = new Phaseo({ apiKey: process.env.PHASEO_API_KEY! });

  const response = await client.generateResponse({
    model: "google/gemini-3.1-flash-lite",
    input: "Give me one release-note bullet for the last deploy.",
    provider: {
      sort: "price",
    },
  });

  console.log(response.output_text);
  ```

  ```python Python SDK theme={null}
  from phaseo import Phaseo

  client = Phaseo(api_key="YOUR_API_KEY")

  response = client.generate_response(
      {
          "model": "google/gemini-3.1-flash-lite",
          "input": "Give me one release-note bullet for the last deploy.",
          "provider": {
              "sort": "price",
          },
      }
  )

  print(response.get("output_text"))
  ```

  ```go Go SDK theme={null}
  package main

  import (
    "context"
    "fmt"

    phaseo "github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3"
  )

  func main() {
    client := phaseo.New("YOUR_API_KEY", "https://api.phaseo.app/v1")

    response, err := client.GenerateResponse(context.Background(), phaseo.ResponsesRequest{
      Model: "google/gemini-3.1-flash-lite",
      Input: "Give me one release-note bullet for the last deploy.",
      Provider: map[string]interface{}{
        "sort": "price",
      },
    })
    if err != nil {
      panic(err)
    }

    fmt.Println(response)
  }
  ```

  ```csharp C# SDK theme={null}
  using PhaseoSdk;
  using System.Collections.Generic;

  var client = new Phaseo("YOUR_API_KEY");

  var response = await client.GenerateResponse(new Dictionary<string, object>
  {
      ["model"] = "google/gemini-3.1-flash-lite",
      ["input"] = "Give me one release-note bullet for the last deploy.",
      ["provider"] = new Dictionary<string, object>
      {
          ["sort"] = "price"
      }
  });

  Console.WriteLine(response);
  ```

  ```php PHP SDK theme={null}
  <?php
  require 'vendor/autoload.php';

  use Phaseo\Sdk\Phaseo;

  $client = new Phaseo(getenv('PHASEO_API_KEY') ?: 'YOUR_API_KEY');

  $response = $client->generateResponse([
      'model' => 'google/gemini-3.1-flash-lite',
      'input' => 'Give me one release-note bullet for the last deploy.',
      'provider' => [
          'sort' => 'price',
      ],
  ]);

  print_r($response);
  ```

  ```ruby Ruby SDK theme={null}
  require 'phaseo_sdk'

  client = PhaseoSdk::Phaseo.new(api_key: ENV.fetch('PHASEO_API_KEY', 'YOUR_API_KEY'))

  response = client.generate_response(
    model: 'google/gemini-3.1-flash-lite',
    input: 'Give me one release-note bullet for the last deploy.',
    provider: {
      sort: 'price'
    }
  )

  puts response
  ```
</CodeGroup>

इस फ़्लो में ये रूटिंग सॉर्ट उपलब्ध हैं:

* `price`
* `latency`
* `throughput`

## 2. वर्कलोड के अनुसार सॉर्ट चुनें

इसे इस तरह चुनें:

* जब लागत टेल लेटेंसी से अधिक महत्वपूर्ण हो, तब `price`
* चैट, कोपायलट और मानव-सहभागिता वाले टूल के लिए `latency`
* अधिक मात्रा में जनरेशन या बैकफ़िल के लिए `throughput`

## 3. समझें कि गेटवे किन चीज़ों की तुलना करता है

अनुरोध-स्तरीय सॉर्ट स्पष्ट करने पर, गेटवे सामान्य संतुलित भारित शफ़ल के बजाय उम्मीदवारों को नियतात्मक ढंग से रैंक करता है।

टेक्स्ट मॉडल के लिए:

* `price` योग्य प्रदाताओं में समान मूल्य आधार की तुलना करता है
* साझा टेक्स्ट मीटर उपलब्ध होने पर गेटवे `input_text_tokens` और `output_text_tokens` से मेल खाने वाले विकल्पों को प्राथमिकता देता है
* `latency` प्रदाता के नवीनतम लेटेंसी डेटा का उपयोग करता है
* `throughput` नवीनतम थ्रूपुट माप का उपयोग करता है

## 4. प्रदाताओं का समूह व्यावहारिक रखें

ज़रूरत पड़ने पर पहले उम्मीदवारों का दायरा सीमित करने से सॉर्ट बेहतर काम करता है।

उदाहरण के लिए, केवल स्वीकृत प्रदाताओं के समूह में सॉर्ट करें:

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.phaseo.app/v1/responses \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "google/gemini-3.1-flash-lite",
      "input": "Summarize the incident in one sentence.",
      "provider": {
        "only": ["google-vertex", "google-vertex-eu"],
        "sort": "latency"
      }
    }'
  ```

  ```typescript TypeScript SDK theme={null}
  import Phaseo from "@phaseo/sdk";

  const client = new Phaseo({ apiKey: process.env.PHASEO_API_KEY! });

  const response = await client.generateResponse({
    model: "google/gemini-3.1-flash-lite",
    input: "Summarize the incident in one sentence.",
    provider: {
      only: ["google-vertex", "google-vertex-eu"],
      sort: "latency",
    },
  });

  console.log(response.output_text);
  ```

  ```python Python SDK theme={null}
  from phaseo import Phaseo

  client = Phaseo(api_key="YOUR_API_KEY")

  response = client.generate_response(
      {
          "model": "google/gemini-3.1-flash-lite",
          "input": "Summarize the incident in one sentence.",
          "provider": {
              "only": ["google-vertex", "google-vertex-eu"],
              "sort": "latency",
          },
      }
  )

  print(response.get("output_text"))
  ```

  ```go Go SDK theme={null}
  package main

  import (
    "context"
    "fmt"

    phaseo "github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3"
  )

  func main() {
    client := phaseo.New("YOUR_API_KEY", "https://api.phaseo.app/v1")

    response, err := client.GenerateResponse(context.Background(), phaseo.ResponsesRequest{
      Model: "google/gemini-3.1-flash-lite",
      Input: "Summarize the incident in one sentence.",
      Provider: map[string]interface{}{
        "only": []string{"google-vertex", "google-vertex-eu"},
        "sort": "latency",
      },
    })
    if err != nil {
      panic(err)
    }

    fmt.Println(response)
  }
  ```

  ```csharp C# SDK theme={null}
  using PhaseoSdk;
  using System.Collections.Generic;

  var client = new Phaseo("YOUR_API_KEY");

  var response = await client.GenerateResponse(new Dictionary<string, object>
  {
      ["model"] = "google/gemini-3.1-flash-lite",
      ["input"] = "Summarize the incident in one sentence.",
      ["provider"] = new Dictionary<string, object>
      {
          ["only"] = new[] { "google-vertex", "google-vertex-eu" },
          ["sort"] = "latency"
      }
  });

  Console.WriteLine(response);
  ```

  ```php PHP SDK theme={null}
  <?php
  require 'vendor/autoload.php';

  use Phaseo\Sdk\Phaseo;

  $client = new Phaseo(getenv('PHASEO_API_KEY') ?: 'YOUR_API_KEY');

  $response = $client->generateResponse([
      'model' => 'google/gemini-3.1-flash-lite',
      'input' => 'Summarize the incident in one sentence.',
      'provider' => [
          'only' => ['google-vertex', 'google-vertex-eu'],
          'sort' => 'latency',
      ],
  ]);

  print_r($response);
  ```

  ```ruby Ruby SDK theme={null}
  require 'phaseo_sdk'

  client = PhaseoSdk::Phaseo.new(api_key: ENV.fetch('PHASEO_API_KEY', 'YOUR_API_KEY'))

  response = client.generate_response(
    model: 'google/gemini-3.1-flash-lite',
    input: 'Summarize the incident in one sentence.',
    provider: {
      only: ['google-vertex', 'google-vertex-eu'],
      sort: 'latency'
    }
  )

  puts response
  ```
</CodeGroup>

## 5. रैंक किए गए परिणाम की पुष्टि करें

debugging करते समय **Gateway -> उपयोग** में request देखें और यह खोजें:

* विचार किए गए प्रदाता
* रैंक किए गए प्रदाता
* कीमत, लेटेंसी या थ्रूपुट के रूटिंग स्कोर कारक

इससे आसानी से पुष्टि हो जाती है कि गेटवे ने अपेक्षा के अनुसार सॉर्ट किया या नहीं।

## संबंधित गाइड

* [रूटिंग और फ़ॉलबैक](../guides/routing-and-fallbacks.mdx)
* [प्रीसेट रोल आउट करें और रूटिंग डीबग करें](./preset-rollout-and-routing-debug.mdx)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.