Platform For AI:Deploy large language models on 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
    }'

No código acima, substitua os seguintes parâmetros:

• Substitua <EAS_ENDPOINT> e <EAS_TOKEN> pelo endpoint e token do seu service implantado.

• Troque <model_name> pelo nome do modelo. Para vLLM ou SGLang, obtenha o nome do modelo por meio da API de lista de modelos em <EAS_ENDPOINT>/v1/models.

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

OpenAI SDK

Recomendamos o uso do SDK oficial para Python na interação com o service. Certifique-se de ter instalado o OpenAI SDK: 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

Caso prefira não adicionar uma dependência ao OpenAI SDK, utilize a biblioteca 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. Instale o provedor de modelos compatível com a API OpenAI

   Clique no seu avatar no canto superior direito e selecione Settings. No painel à esquerda, escolha Model Providers. Se OpenAI-API-compatible não estiver na Model List, localize-o na lista abaixo e clique em Install.

2. Adicione um modelo

   Clique em Add Model no canto inferior direito do cartão OpenAI-API-compatible e configure os seguintes parâmetros:

   • Model type: Selecione LLM.

   • Model name: Para uma implantação vLLM, envie uma requisição GET para o endpoint /v1/models para obter o nome. Neste exemplo, insira Qwen3-8B.

   • API key: Insira o token do seu service PAI-EAS.

   • API endpoint URL: Insira o endpoint público do seu service PAI-EAS e adicione /v1 ao final.

3. Teste a integração

   1. Na página principal do Dify, clique em Create Blank App, selecione o tipo Chatflow, insira um nome para a aplicação e outras informações, e então clique em Create.

   2. Clique no nó LLM, selecione o modelo adicionado e defina o contexto e os prompts. Escolha Qwen3-8B CHAT na categoria OpenAI-API-compatible. No prompt SYSTEM, insira uma descrição de função e referencie a variável de contexto sys.query. Na área USER, adicione as variáveis sys.query e sys.files. Ajuste os parâmetros do modelo, como Max Tokens (o padrão é 512), Presence Penalty e Thinking Mode, conforme necessário.

   3. Clique em Preview no canto superior direito e faça uma pergunta.

      O bot processa a pergunta por meio do workflow e retorna uma resposta. O topo da área de conversa exibe um status de Deep thinking e o tempo decorrido.

Chatbox

1. Acesse o Chatbox para baixar e instalar o cliente para o seu dispositivo, ou clique em Launch Web App para usar a versão web. Este exemplo utiliza macOS M3.

2. Adicione um provedor de modelos. Clique em Settings, adicione um provedor de modelos, insira um nome como pai e selecione OpenAI API Compatible como modo de API.

3. Selecione o provedor pai e configure os seguintes parâmetros:

   • API key: Insira o token do seu service PAI-EAS.

   • API host: Insira o endpoint público do seu service PAI-EAS e adicione /v1 ao final.

   • API path: Deixe este campo vazio.

   • Model: Clique em Get para adicionar o modelo. O mecanismo de inferência BladeLLM não suporta recuperação de modelos via API. Se estiver usando BladeLLM, adicione o modelo manualmente clicando em New.

4. Teste o chat. Clique em New Chat e selecione o service de modelo no canto inferior direito da caixa de entrada de texto.

   O topo da interface de chat exibe o prompt do sistema, como You are a helpful assistant.. Digite uma pergunta como "Who are you?" na caixa de texto e envie. A área de resposta do assistente mostra uma seção recolhida de Deep thinking com o tempo de raciocínio, seguida pela resposta do modelo.

Cherry Studio

1. Instale o cliente

   Visite o Cherry Studio para baixar e instalar o cliente.

   Você também pode baixá-lo em https://github.com/CherryHQ/cherry-studio/releases .

2. Configure o service de modelo

   1. Clique no ícone de configurações no canto inferior esquerdo. Na seção Model Service, clique em Add. Em Provider name, insira um nome personalizado, como PAI, e defina o tipo de provedor como OpenAI. Clique em OK.

   2. No campo API key, insira o token do seu service PAI-EAS. No campo API address, insira o endpoint público do seu service PAI-EAS.

   3. Clique em Add e insira o nome do modelo no campo Model ID. Para implantações vLLM, obtenha o nome enviando uma requisição GET para a API /v1/models. Por exemplo, insira Qwen3-8B. O nome diferencia maiúsculas de minúsculas. Para o API Address, insira a URL, mas omita o número da versão v1 no final. Se a URL terminar com o caractere #, o sistema força o uso do caminho /v1/chat/completions. Após a configuração, a seção Model identifica e lista automaticamente os modelos disponíveis, como Qwen3-8B.

   4. Clique em Test ao lado do campo de entrada API key para verificar a conectividade.

3. Teste rapidamente o modelo

   Retorne à interface de chat, selecione o modelo na parte superior e inicie uma conversa.

   Por exemplo, se você inserir Who are you? e o modelo Qwen3-8B responder com uma autoapresentação, isso indica que o modelo está implantado e funcionando corretamente.

LangChain

O LangChain é um framework Python comum para criar aplicações de LLM. Como um service do PAI-EAS é compatível com a API OpenAI, você pode chamar o service diretamente com langchain_openai.ChatOpenAI, por exemplo, para compor um modelo de prompt em uma cadeia.

1. Instale as dependências

   pip install langchain langchain-openai

2. Configure o modelo. Configure o ChatOpenAI com os seguintes parâmetros:

   • base_url: Insira o endpoint público do seu service PAI-EAS e adicione /v1 ao final.

   • api_key: Insira o token do seu service PAI-EAS.

   • model: Insira o nome do modelo. Para uma implantação vLLM, envie uma requisição GET para o endpoint /v1/models para obter o nome. Neste exemplo, insira Qwen3-8B.

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

   Importante

   Você deve adicionar /v1 ao base_url. Se você inserir o endpoint público do seu service PAI-EAS sem /v1, a chamada retornará 404.

3. Invocação da cadeia. Componha o modelo com ChatPromptTemplate usando o operador |:

   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)