Platform For AI:Déployer des grands modèles de langage sur PAI-EAS

cURL

curl -X POST <EAS_ENDPOINT>/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<model_name>",
        "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "hello"
        }
        ],
        "max_tokens":1024,
        "temperature": 0.7,
        "top_p": 0.8,
        "stream":true
    }'

Dans le code précédent, remplacez les paramètres suivants :

• Remplacez <EAS_ENDPOINT> et <EAS_TOKEN> par le point de terminaison et le jeton de votre service déployé.

• Remplacez <model_name> par le nom du modèle. Pour vLLM ou SGLang, vous pouvez obtenir le nom du modèle via l'API de liste des modèles à l'adresse <EAS_ENDPOINT>/v1/models.

  curl -X GET <EAS_ENDPOINT>/v1/models -H "Authorization: <EAS_TOKEN>"

OpenAI SDK

Nous recommandons d'utiliser le SDK Python officiel pour interagir avec le service. Assurez-vous d'avoir installé le SDK OpenAI : pip install openai.

from openai import OpenAI

# 1. Configure the client.
# Replace <EAS_TOKEN> with the token of your deployed service.
openai_api_key = "<EAS_TOKEN>"
# Replace <EAS_ENDPOINT> with the endpoint of your deployed service.
openai_api_base = "<EAS_ENDPOINT>/v1"

client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

# 2. Get the model name.
# For BladeLLM, set model = "". BladeLLM does not require a model parameter
# and does not support getting the model name by using client.models.list().
# Set it to an empty string to meet the mandatory parameter requirement of the OpenAI SDK.
models = client.models.list()
model = models.data[0].id
print(model)

# 3. Send a chat request.
# Both streaming (stream=True) and non-streaming (stream=False) outputs are supported.
stream = True
chat_completion = client.chat.completions.create(
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "hello"},          
    ],
    model=model,
    top_p=0.8,
    temperature=0.7,
    max_tokens=1024,
    stream=stream,
)

if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

Python requests

Si vous souhaitez éviter d'ajouter une dépendance au SDK OpenAI, vous pouvez utiliser la bibliothèque requests.

import json
import requests

# Replace <EAS_ENDPOINT> with the endpoint of your deployed service.
EAS_ENDPOINT = "<EAS_ENDPOINT>"
# Replace <EAS_TOKEN> with the token of your deployed service.
EAS_TOKEN = "<EAS_TOKEN>"
# Replace <model_name> with the model name. You can get it from the <EAS_ENDPOINT>/v1/models API.
# For BladeLLM, this API is not supported. You can omit the "model" field or set it to "".
model = "<model_name>"

url = f"{EAS_ENDPOINT}/v1/chat/completions"
headers = {
    "Content-Type": "application/json",
    "Authorization": EAS_TOKEN,
}

stream = True
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "hello"},
]

req = {
    "messages": messages,
    "stream": stream,
    "temperature": 0.7,
    "top_p": 0.8,
    "max_tokens": 1024,
    "model": model,
}
response = requests.post(
    url,
    json=req,
    headers=headers,
    stream=stream,
)

if stream:
    for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False):
        msg = chunk.decode("utf-8")
        # The following code processes Server-Sent Events (SSE) formatted streaming responses.
        if msg.startswith("data:"):
            info = msg[6:]
            if info == "[DONE]":
                break
            else:
                resp = json.loads(info)
                if resp["choices"][0]["delta"].get("content") is not None:
                    print(resp["choices"][0]["delta"]["content"], end="", flush=True)
else:
    resp = json.loads(response.text)
    print(resp["choices"][0]["message"]["content"])

Dify

1. Installer le fournisseur de modèle compatible avec l'API OpenAI

   Cliquez sur votre avatar dans le coin supérieur droit et sélectionnez Settings. Dans le volet de gauche, sélectionnez Model Providers. Si OpenAI-API-compatible ne figure pas dans la Model List, recherchez-le dans la liste ci-dessous et cliquez sur Install.

2. Ajouter un modèle

   Cliquez sur Add Model dans le coin inférieur droit de la carte OpenAI-API-compatible et configurez les paramètres suivants :

   • Model type : sélectionnez LLM.

   • Model name : pour un déploiement vLLM, envoyez une requête GET au point de terminaison /v1/models pour obtenir le nom. Pour cet exemple, saisissez Qwen3-8B.

   • API key : saisissez le jeton de votre service PAI-EAS.

   • API endpoint URL : saisissez le point de terminaison public de votre service PAI-EAS et ajoutez /v1 à la fin.

3. Tester l'intégration

   1. Sur la page principale de Dify, cliquez sur Create Blank App, sélectionnez le type Chatflow, saisissez un nom d'application et d'autres informations, puis cliquez sur Create.

   2. Cliquez sur le nœud LLM, sélectionnez le modèle que vous avez ajouté, et définissez le contexte et les invites. Sélectionnez Qwen3-8B CHAT dans la catégorie OpenAI-API-compatible. Dans l'invite SYSTEM, saisissez une description de rôle et référencez la variable de contexte sys.query. Dans la zone USER, ajoutez les variables sys.query et sys.files. Vous pouvez ajuster les paramètres du modèle tels que Max Tokens (la valeur par défaut est 512), Presence Penalty et Thinking Mode selon vos besoins.

   3. Cliquez sur Preview dans le coin supérieur droit et posez une question.

      Le bot traite la question via le workflow et renvoie une réponse. Le haut de la zone de conversation affiche un état Deep thinking et le temps écoulé.

Chatbox

1. Accédez à Chatbox pour télécharger et installer le client adapté à votre appareil, ou cliquez sur Launch Web App pour la version web. Cet exemple utilise macOS M3.

2. Ajouter un fournisseur de modèle. Cliquez sur Settings, ajoutez un fournisseur de modèle, saisissez un nom tel que pai, et sélectionnez OpenAI API Compatible comme mode API.

3. Sélectionnez le fournisseur pai et configurez les paramètres suivants :

   • API key : saisissez le jeton de votre service PAI-EAS.

   • API host : saisissez le point de terminaison public de votre service PAI-EAS et ajoutez /v1 à la fin.

   • API path : laissez ce champ vide.

   • Model : cliquez sur Get pour ajouter le modèle. Le moteur d'inférence BladeLLM ne prend pas en charge la récupération des modèles via l'API. Si vous utilisez BladeLLM, ajoutez le modèle manuellement en cliquant sur New.

4. Tester le chat. Cliquez sur New Chat et sélectionnez le service de modèle dans le coin inférieur droit de la zone de saisie de texte.

   Le haut de l'interface de chat affiche l'invite système, telle que You are a helpful assistant.. Saisissez une question telle que « Who are you? » dans la zone de texte et envoyez-la. La zone de réponse de l'assistant affiche une section Deep thinking réduite avec le temps de réflexion, suivie de la réponse du modèle.

Cherry Studio

1. Installer le client

   Visitez Cherry Studio pour télécharger et installer le client.

   Vous pouvez également le télécharger depuis https://github.com/CherryHQ/cherry-studio/releases .

2. Configurer le service de modèle

   1. Cliquez sur l'icône des paramètres dans le coin inférieur gauche. Sous la section Model Service, cliquez sur Add. Dans Provider name, saisissez un nom personnalisé, tel que PAI, et définissez le type de fournisseur sur OpenAI. Cliquez sur OK.

   2. Dans le champ API key, saisissez le jeton de votre service PAI-EAS. Dans le champ API address, saisissez le point de terminaison public de votre service PAI-EAS.

   3. Cliquez sur Add et saisissez le nom du modèle dans le champ Model ID. Pour les déploiements vLLM, vous pouvez obtenir le nom en envoyant une requête GET à l'API /v1/models. Par exemple, saisissez Qwen3-8B. Le nom respecte la casse. Pour API Address, saisissez l'URL mais omettez le numéro de version v1 à la fin. Si l'URL se termine par le caractère #, le système force l'utilisation du chemin /v1/chat/completions. Une fois la configuration terminée, la section Model identifie et répertorie automatiquement les modèles disponibles, tels que Qwen3-8B.

   4. Cliquez sur Test à côté du champ de saisie API key pour vérifier la connectivité.

3. Tester rapidement le modèle

   Revenez à l'interface de chat, sélectionnez le modèle en haut et démarrez une conversation.

   Par exemple, si vous saisissez Who are you? et que le modèle Qwen3-8B répond par une présentation, cela indique que le modèle est déployé et fonctionne correctement.

LangChain

LangChain est un framework Python courant pour construire des applications LLM. Étant donné qu'un service PAI-EAS est compatible avec l'API OpenAI, vous pouvez appeler le service directement avec langchain_openai.ChatOpenAI, par exemple pour composer un modèle d'invite en une chaîne.

1. Installer les dépendances

   pip install langchain langchain-openai

2. Configurer le modèle. Configurez ChatOpenAI avec les paramètres suivants :

   • base_url : saisissez le point de terminaison public de votre service PAI-EAS et ajoutez /v1 à la fin.

   • api_key : saisissez le jeton de votre service PAI-EAS.

   • model : saisissez le nom du modèle. Pour un déploiement vLLM, envoyez une requête GET au point de terminaison /v1/models pour obtenir le nom. Pour cet exemple, saisissez Qwen3-8B.

   from langchain_openai import ChatOpenAI
   
   llm = ChatOpenAI(
       base_url="<EAS_ENDPOINT>/v1",
       api_key="<EAS_TOKEN>",
       model="<model_name>"
   )

   Important

   Vous devez ajouter /v1 à base_url. Si vous saisissez le point de terminaison public de votre service PAI-EAS sans /v1, l'appel renvoie une erreur 404.

3. Invocation de chaîne. Vous pouvez composer le modèle avec ChatPromptTemplate en utilisant l'opérateur | :

   from langchain_core.prompts import ChatPromptTemplate
   
   prompt = ChatPromptTemplate.from_messages([
       ("system", "You are a helpful assistant."),
       ("user", "{input}")
   ])
   
   chain = prompt | llm
   response = chain.invoke({"input": "Who are you?"})
   print(response.content)