Beranda>Terkait pemrograman>Kode Sumber AI
Unduh

Pelayanan AI Generatif Supercharge dengan Friendli

Status CI

Klien Friendli menawarkan antarmuka yang nyaman untuk berinteraksi dengan layanan titik akhir yang disediakan oleh Friendli Suite, solusi terbaik untuk melayani model AI generatif. Dirancang untuk fleksibilitas dan kinerja, ini mendukung operasi sinkron dan asinkron, sehingga memudahkan untuk mengintegrasikan kemampuan AI yang kuat ke dalam aplikasi Anda.

Instalasi

Untuk memulai Friendli, instal paket klien menggunakan pip : 

pip install friendli-client

Penting

Anda harus menyetel variabel lingkungan FRIENDLI_TOKEN sebelum menginisialisasi instance klien dengan client = Friendli() . Alternatifnya, Anda dapat memberikan nilai token akses pribadi Anda sebagai argumen token saat membuat klien, seperti: 

 from friendli import Friendli

client = Friendli ( token = "YOUR PERSONAL ACCESS TOKEN" )

Titik Akhir Tanpa Server yang Ramah

Titik Akhir Tanpa Server Friendli menawarkan antarmuka klik dan putar yang sederhana untuk mengakses model sumber terbuka populer seperti Llama 3.1. Dengan penagihan bayar per token, ini ideal untuk eksplorasi dan eksperimen.

Untuk berinteraksi dengan model yang dihosting oleh titik akhir tanpa server, berikan kode model yang ingin Anda gunakan dalam argumen model . Lihat tabel harga untuk daftar kode model yang tersedia dan harganya. 

 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 )

Titik Akhir Khusus Friendli

Titik Akhir Khusus Friendli memungkinkan Anda menjalankan model AI generatif khusus pada sumber daya GPU khusus.

Untuk berinteraksi dengan titik akhir khusus, berikan ID titik akhir dalam argumen 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 )

Wadah Ramah

Friendli Container sangat cocok untuk pengguna yang lebih memilih untuk melayani LLM dalam infrastruktur mereka sendiri. Dengan menerapkan Mesin Friendli dalam container di GPU lokal atau cloud, Anda dapat mempertahankan kontrol penuh atas data dan operasi Anda, memastikan keamanan dan kepatuhan terhadap kebijakan internal. 

 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 )

Penggunaan Asinkron 

 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 ())

Penggunaan Streaming 

 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 )

Klien async ( AsyncFriendli ) menggunakan antarmuka yang sama untuk mengalirkan respons. 

 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 ())

Penggunaan Tingkat Lanjut

Mengirim Permintaan ke Adaptor LoRA

Jika titik akhir Anda menyajikan model Multi-LoRA, Anda dapat mengirim permintaan ke salah satu adaptor dengan menyediakan rute adaptor dalam argumen model .

Untuk Titik Akhir Khusus Friendli, berikan ID titik akhir dan rute adaptor yang dipisahkan dengan titik dua ( : ). 

 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" ,
        }
    ],
)

Untuk Friendli Container, cukup berikan nama adaptornya. 

 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" ,
        }
    ],
)

Menggunakan Antarmuka gRPC

Penting

gRPC hanya didukung oleh Friendli Container, dan hanya API streaming v1/completions yang tersedia.

Saat Frienldi Container berjalan dalam mode gPRC, klien dapat berinteraksi dengan server gRPC dengan menginisialisasinya menggunakan argumen 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 )

Mengonfigurasi Klien HTTP

Klien menggunakan httpx untuk mengirim permintaan HTTP. Anda dapat memberikan httpx.Client yang disesuaikan saat menginisialisasi Friendli . 

 import httpx
from friendli import Friendli

with httpx . Client () as client :
    client = Friendli ( http_client = http_client )

Untuk klien async, Anda dapat menyediakan httpx.AsyncClient . 

 import httx
from friendli import AsyncFriendli

with httpx . AsyncClient () as client :
    client = AsyncFriendli ( http_client = http_client )

Mengonfigurasi Saluran gRPC 

 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 )

Anda dapat menggunakan antarmuka yang sama untuk klien async. 

 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 )

Mengelola Sumber Daya

Klien Friendli menyediakan beberapa metode untuk mengelola dan melepaskan sumber daya.

Menutup Klien

Klien Friendli dan AsyncFriendli dapat menyimpan koneksi jaringan atau sumber daya lainnya selama masa pakainya. Untuk memastikan sumber daya ini dirilis dengan benar, Anda harus memanggil metode close() atau menggunakan klien dalam pengelola konteks. 

 from friendli import Friendli

client = Friendli ()

# Use the client for various operations...

# When done, close the client to release resources
client . close ()

Untuk klien asinkron, polanya serupa: 

 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 ()

Anda juga dapat menggunakan manajer konteks untuk menutup klien secara otomatis dan melepaskan sumber daya ketika blok keluar, menjadikannya cara yang lebih aman dan nyaman untuk mengelola sumber daya. 

 from friendli import Friendli

with Friendli () as client :
    ...

Untuk penggunaan asinkron: 

 import asyncio
from friendli import AsyncFriendli

async def main ():
    async with AsyncFriendli () as client :
        ...


asyncio . run ( main ())

Mengelola Respons Streaming

Saat menggunakan respons streaming, sangat penting untuk menutup koneksi HTTP dengan benar setelah interaksi selesai. Secara default, koneksi secara otomatis ditutup setelah semua data dari aliran telah digunakan (misalnya, ketika perulangan for mencapai akhir). Namun, jika streaming terganggu oleh pengecualian atau masalah lainnya, koneksi mungkin tetap terbuka dan tidak akan dilepaskan hingga dikumpulkan dari sampah. Untuk memastikan bahwa semua koneksi dan sumber daya yang mendasari dilepaskan dengan benar, penting untuk menutup koneksi secara eksplisit, terutama ketika streaming dihentikan sebelum waktunya. 

 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 use

Untuk streaming asinkron: 

 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 ())

Anda juga dapat menggunakan manajer konteks untuk menutup klien secara otomatis dan melepaskan sumber daya ketika blok keluar, menjadikannya cara yang lebih aman dan nyaman untuk mengelola sumber daya. 

 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 )

Untuk streaming asinkron: 

 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 ())

Membatalkan Aliran gRPC

Saat menggunakan antarmuka gRPC dengan streaming, Anda mungkin ingin membatalkan operasi streaming yang sedang berlangsung sebelum selesai. Ini sangat berguna jika Anda perlu menghentikan streaming karena waktu habis atau kondisi lainnya.

Untuk streaming gRPC sinkron: 

 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 interruption

Untuk streaming gRPC asinkron: 

 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 ())

Contoh CLI

Anda juga dapat memanggil API generasi secara langsung dengan CLI. 

friendli api chat-completions create 
  -g " user Tell me how to make a delicious pancake " 
  -m meta-llama-3.1-8b-instruct

Untuk informasi lebih lanjut tentang friendli , jalankanfriendli friendli --help di shell terminal Anda. Ini akan memberi Anda daftar rinci opsi yang tersedia dan petunjuk penggunaan.

Tip

Lihat dokumentasi resmi kami untuk mempelajari lebih lanjut!

Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua