friendli client
v1.5.6 ?
Turbine o serviço de IA generativa com Friendli
O Friendli Client oferece uma interface conveniente para interagir com serviços de endpoint fornecidos pelo Friendli Suite, a solução definitiva para servir modelos generativos de IA. Projetado para oferecer flexibilidade e desempenho, ele oferece suporte a operações síncronas e assíncronas, facilitando a integração de poderosos recursos de IA em seus aplicativos.
Para começar com o Friendli, instale o pacote do cliente usando pip :
pip install friendli-clientImportante
Você deve definir a variável de ambiente FRIENDLI_TOKEN antes de inicializar a instância do cliente com client = Friendli() . Como alternativa, você pode fornecer o valor do seu token de acesso pessoal como argumento token ao criar o cliente, da seguinte forma:
from friendli import Friendli
client = Friendli ( token = "YOUR PERSONAL ACCESS TOKEN" )O Friendli Serverless Endpoint oferece uma interface simples e fácil de usar para acessar modelos populares de código aberto, como o Llama 3.1. Com faturamento pago por token, isso é ideal para exploração e experimentação.
Para interagir com modelos hospedados por endpoints sem servidor, forneça o código do modelo que você deseja usar no argumento model . Consulte a tabela de preços para obter uma lista de códigos de modelo disponíveis e seus preços.
from friendli import Friendli
client = Friendli ()
chat_completion = client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
)
print ( chat_completion . choices [ 0 ]. message . content )Os endpoints dedicados Friendli permitem que você execute seus modelos de IA generativos personalizados em recursos de GPU dedicados.
Para interagir com endpoints dedicados, forneça o ID do endpoint no argumento model .
import os
from friendli import Friendli
client = Friendli (
team_id = os . environ [ "TEAM_ID" ], # If not provided, default team is used.
use_dedicated_endpoint = True ,
)
chat_completion = client . chat . completions . create (
model = os . environ [ "ENDPOINT_ID" ],
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
)
print ( chat_completion . choices [ 0 ]. message . content )O Friendli Container é perfeito para usuários que preferem atender LLMs dentro de sua própria infraestrutura. Ao implantar o Friendli Engine em contêineres em suas GPUs locais ou na nuvem, você pode manter controle total sobre seus dados e operações, garantindo segurança e conformidade com políticas internas.
from friendli import Friendli
client = Friendli ( base_url = "http://0.0.0.0:8000" )
chat_completion = client . chat . completions . create (
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
)
print ( chat_completion . choices [ 0 ]. message . content ) import asyncio
from friendli import AsyncFriendli
client = AsyncFriendli ()
async def main () -> None :
chat_completion = await client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
)
print ( chat_completion . choices [ 0 ]. message . content )
asyncio . run ( main ()) from friendli import Friendli
client = Friendli ()
stream = client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
)
for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True ) O cliente assíncrono ( AsyncFriendli ) usa a mesma interface para transmitir a resposta.
import asyncio
from friendli import AsyncFriendli
client = AsyncFriendli ()
async def main () -> None :
stream = await client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
)
async for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
asyncio . run ( main ()) Se o seu endpoint estiver atendendo a um modelo Multi-LoRA, você poderá enviar uma solicitação para um dos adaptadores, fornecendo a rota do adaptador no argumento model .
Para endpoints dedicados Friendli, forneça o ID do endpoint e a rota do adaptador separados por dois pontos ( : ).
import os
from friendli import Friendli
client = Friendli (
team_id = os . environ [ "TEAM_ID" ], # If not provided, default team is used.
use_dedicated_endpoint = True ,
)
chat_completion = client . lora . completions . create (
model = f" { os . environ [ 'ENDPOINT_ID' ] } : { os . environ [ 'ADAPTER_ROUTE' ] } " ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
)Para Friendli Container, basta fornecer o nome do adaptador.
import os
from friendli import Friendli
client = Friendli ( base_url = "http://0.0.0.0:8000" )
chat_completion = client . lora . completions . create (
model = os . environ [ "ADAPTER_NAME" ],
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
)Importante
gRPC é compatível apenas com Friendli Container e apenas a API de streaming de v1/completions está disponível.
Quando o Frienldi Container está sendo executado no modo gPRC, o cliente pode interagir com o servidor gRPC inicializando-o com o argumento use_grpc=True .
from friendli import Friendli
client = Friendli ( base_url = "0.0.0.0:8000" , use_grpc = True )
stream = client . chat . completions . create (
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True , # Only streaming mode is available
)
for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True ) O cliente usa httpx para enviar solicitações HTTP. Você pode fornecer o httpx.Client personalizado ao inicializar Friendli .
import httpx
from friendli import Friendli
with httpx . Client () as client :
client = Friendli ( http_client = http_client ) Para o cliente assíncrono, você pode fornecer httpx.AsyncClient .
import httx
from friendli import AsyncFriendli
with httpx . AsyncClient () as client :
client = AsyncFriendli ( http_client = http_client ) import grpc
from friendli import Friendli
with grpc . insecure_channel ( "0.0.0.0:8000" ) as channel :
client = Friendli ( use_grpc = True , grpc_channel = channel )Você pode usar a mesma interface para o cliente assíncrono.
import grpc . aio
from friendli import AsyncFriendli
async with grpc . aio . insecure_channel ( "0.0.0.0:8000" ) as channel :
client = AsyncFriendli ( use_grpc = True , grpc_channel = channel )O cliente Friendli fornece vários métodos para gerenciar e liberar recursos.
Os clientes Friendli e AsyncFriendli podem manter conexões de rede ou outros recursos durante sua vida útil. Para garantir que esses recursos sejam liberados corretamente, você deve chamar o método close() ou usar o cliente dentro de um gerenciador de contexto.
from friendli import Friendli
client = Friendli ()
# Use the client for various operations...
# When done, close the client to release resources
client . close ()Para o cliente assíncrono, o padrão é semelhante:
import asyncio
from friendli import AsyncFriendli
client = AsyncFriendli ()
# Use the client for various async operations...
# When done, close the client to release resources
await client . close ()Você também pode usar o gerenciador de contexto para fechar automaticamente o cliente e liberar recursos quando o bloco for encerrado, tornando-o uma maneira mais segura e conveniente de gerenciar recursos.
from friendli import Friendli
with Friendli () as client :
...Para uso assíncrono:
import asyncio
from friendli import AsyncFriendli
async def main ():
async with AsyncFriendli () as client :
...
asyncio . run ( main ())Ao usar respostas de streaming, é crucial fechar adequadamente a conexão HTTP após a conclusão da interação. Por padrão, a conexão é fechada automaticamente quando todos os dados do fluxo são consumidos (ou seja, quando o loop for chega ao fim). No entanto, se o streaming for interrompido por exceções ou outros problemas, a conexão poderá permanecer aberta e não será liberada até que seja coletada como lixo. Para garantir que todas as ligações e recursos subjacentes são devidamente libertados, é importante fechar explicitamente a ligação, especialmente quando o streaming é terminado prematuramente.
from friendli import Friendli
client = Friendli ()
stream = client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
)
try :
for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
finally :
stream . close () # Ensure the stream is closed after usePara streaming assíncrono:
import asyncio
from friendli import AsyncFriendli
client = AsyncFriendli ()
async def main ():
stream = await client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
)
try :
async for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
finally :
await stream . close () # Ensure the stream is closed after use
asyncio . run ( main ())Você também pode usar o gerenciador de contexto para fechar automaticamente o cliente e liberar recursos quando o bloco for encerrado, tornando-o uma maneira mais segura e conveniente de gerenciar recursos.
from friendli import Friendli
client = Friendli ()
with client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
) as stream :
for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )Para streaming assíncrono:
import asyncio
from friendli import AsyncFriendli
client = AsyncFriendli ()
async def main ():
async with await client . chat . completions . create (
model = "meta-llama-3.1-8b-instruct" ,
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
) as stream :
async for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
asyncio . run ( main ())Ao usar a interface gRPC com streaming, talvez você queira cancelar uma operação de streaming em andamento antes que ela seja concluída. Isso é particularmente útil se você precisar interromper o fluxo devido a um tempo limite ou alguma outra condição.
Para streaming gRPC síncrono:
from friendli import Friendli
client = Friendli ( base_url = "0.0.0.0:8000" , use_grpc = True )
stream = client . chat . completions . create (
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
)
try :
for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
except SomeException :
stream . cancel () # Cancel the stream in case of an error or interruptionPara streaming gRPC assíncrono:
import asyncio
from friendli import AsyncFriendli
client = AsyncFriendli ( base_url = "0.0.0.0:8000" , use_grpc = True )
async def main ():
stream = await client . chat . completions . create (
messages = [
{
"role" : "user" ,
"content" : "Tell me how to make a delicious pancake" ,
}
],
stream = True ,
)
try :
async for chunk in stream :
print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
except SomeException :
stream . cancel () # Cancel the stream in case of an error or interruption
asyncio . run ( main ())Você também pode chamar as APIs de geração diretamente com a CLI.
friendli api chat-completions create
-g " user Tell me how to make a delicious pancake "
-m meta-llama-3.1-8b-instruct Para obter mais informações sobre o comando friendli , execute friendli --help no shell do terminal. Isso fornecerá uma lista detalhada de opções disponíveis e instruções de uso.
Dica
Confira nossa documentação oficial para saber mais!
