Menyajikan Aplikasi LLM sebagai Endpoint API menggunakan FastAPI di Python

Pendahuluan

Large Language Models (LLM) berada di garis depan AI Generatif, mengubah cara mesin memahami dan menghasilkan teks yang mirip manusia. Model LLM seperti GPT, Claude, LLaMA, Mistral, dll. mendorong inovasi dalam chatbot, pembuatan konten, dan seterusnya, menawarkan kemampuan yang belum pernah ada sebelumnya dalam memroses dan menghasilkan bahasa alami.

Namun, kegunaan sejati LLM melampaui kekuatan komputasinya semata; aksesibilitas adalah kuncinya. API, atau Application Programming Interface, berfungsi sebagai jembatan yang memungkinkan berbagai aplikasi memanfaatkan kekuatan LLM. API memungkinkan pengembang mengintegrasikan fitur pemahaman dan generasi bahasa yang canggih ke dalam aplikasi mereka, mulai dari analisis teks sederhana hingga sistem dialog yang kompleks.

Dalam tutorial ini, kita akan membangun Aplikasi Python sederhana menggunakan model OpenAI GPT dan menyajikannya dengan endpoint API yang akan dikembangkan menggunakan kerangka kerja FastAPI di Python.

Large Language Models

Large Language Models (LLM) merujuk pada sistem kecerdasan buatan tingkat lanjut yang dirancang untuk memahami dan menghasilkan teks mirip manusia. Model-model ini dilatih pada sejumlah besar data, sehingga mampu menangkap pola kompleks, memahami nuansa bahasa, dan menghasilkan respons yang koheren.

LLM memiliki kemampuan untuk melakukan berbagai tugas terkait bahasa, termasuk penerjemahan bahasa, pelengkapan teks, peringkasan, dan bahkan berinteraksi dalam percakapan. GPT adalah salah satu contoh LLM.

Dalam artikel ini, kita akan membangun aplikasi Python sederhana menggunakan API GPT dari OpenAI lalu membuat endpoint REST untuk aplikasi kita menggunakan kerangka kerja FastAPI di Python.

LLM adalah salah satu jenis AI Generatif. Jika Anda ingin mempelajari AI Generatif dan bagaimana AI ini dapat meningkatkan kreativitas Anda, baca postingan blog kami tentang Menggunakan AI Generatif untuk Meningkatkan Kreativitas dan podcast kami, Di Balik Revolusi AI Generatif.

Anda juga dapat mendaftar untuk kursus mendatang kami tentang Konsep Large Language Models.

Apa itu API?

Application Programming Interface (API) adalah tulang punggung komunikasi perangkat lunak, yang memungkinkan sistem, aplikasi, dan perangkat yang berbeda berinteraksi dan berbagi data secara mulus. API bertindak sebagai serangkaian aturan dan protokol yang memungkinkan entitas perangkat lunak berkomunikasi, menawarkan cara yang telah ditentukan bagi satu aplikasi untuk memanfaatkan kemampuan atau data dari aplikasi lain tanpa perlu memahami cara kerja internalnya.

API ada di mana-mana dalam ekosistem digital saat ini, memberdayakan layanan web, aplikasi seluler, dan komputasi awan, serta memfasilitasi komunikasi antar aplikasi dan integrasi layanan pihak ketiga. API menyederhanakan proses pengembangan dengan menyediakan blok bangunan yang dapat digunakan pengembang untuk mempercepat pembuatan perangkat lunak baru, meningkatkan fungsionalitas dan pengalaman pengguna tanpa harus memulai dari nol.

Melalui API, pengembang dapat memperluas aplikasi mereka dengan cara yang sebaliknya rumit atau bahkan tidak mungkin, menjadikannya komponen penting dalam pengembangan perangkat lunak modern.

Sumber Gambar

Jika Anda tertarik mempelajari rekayasa terkait penerapan model pembelajaran mesin di dunia nyata, lihat panduan komprehensif tentang Machine Learning, Pipeline, Deployment, dan MLOps. Anda juga dapat melihat kursus gratis Pengantar API di Datacamp.

FastAPI

FastAPI adalah kerangka kerja Python yang dirancang untuk membangun API berkinerja tinggi. Popularitasnya didorong oleh kecepatannya, kemudahan penggunaan, dan kompatibilitas dengan pemrograman asinkron. FastAPI memudahkan pengembang mengekspos fungsionalitas LLM sebagai endpoint API, sehingga penerapan, pengelolaan, dan penskalaan layanan bertenaga AI menjadi lebih sederhana.

FastAPI menonjol berkat kinerja dan efisiensinya, memanfaatkan fitur modern Python seperti petunjuk tipe dan pemrograman asinkron untuk memberikan peningkatan kecepatan yang menyaingi NodeJS bahkan Go.

Keunggulan kinerja ini krusial untuk aplikasi yang memerlukan pemrosesan data real-time dan penanganan permintaan konkuren, seperti yang berinteraksi dengan LLM. Kemampuannya untuk secara otomatis memvalidasi data masuk dan melakukan serialisasi respons mengurangi boilerplate, menjadikan pengembangan API lebih rapi dan lugas.

Fitur dokumentasi otomatis, yang memanfaatkan standar seperti OpenAPI, memberikan dokumentasi API yang jelas dan interaktif bagi pengembang dan pengguna, sehingga semakin menyederhanakan proses integrasi dan pengujian.

Contoh Pembuatan API:

from typing import Union

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}Didukung oleh

Kode ini membuat server web sederhana menggunakan FastAPI. Server merespons dua jenis permintaan web: satu yang menyapa pengguna dengan "Hello World" saat mereka mengunjungi beranda ("/"), dan satu lagi yang menampilkan ID item dan parameter kueri opsional "q" saat pengguna mengunjungi halaman item tertentu ("/items/{item_id}"). ID item wajib dan harus berupa bilangan bulat, sedangkan parameter kueri "q" bersifat opsional dan bisa berupa string atau tidak ada.

Jalankan server FastAPI dengan:

Membangun aplikasi ujung-ke-ujung di Python

Tujuan utama blog ini adalah menunjukkan cara cepat membangun endpoint REST API untuk aplikasi LLM Anda. Kita akan membuat aplikasi Python sederhana (hanya satu fungsi) yang menggunakan API OpenAI GPT-4 dan menerjemahkan teks bahasa Inggris ke bahasa Prancis. Aplikasi ini hanya memiliki satu fungsi yaitu translate_text:

from openai import OpenAI
import os

os.environ["OPENAI_API_KEY"] = "..."

# Initialize OpenAI client with your API key
client = OpenAI()

def translate_text(input_str):
    completion = client.chat.completions.create(
        model="gpt-4-0125-preview",
        messages=[
            {
                "role": "system",
                "content": "You are an expert translator who translates text from english to french and only return translated text",
            },
            {"role": "user", "content": input_str},
        ],
    )

    return completion.choices[0].message.contentDidukung oleh

Fungsi ini menerima satu masukan dari pengguna dan cukup meneruskannya ke model OpenAI GPT-4. Fungsi ini memiliki prompt sistem untuk mendefinisikan konteks, dan prompt pengguna adalah teks yang kita terima dari pengguna dalam input_str.

Anda dapat menguji fungsi ini dengan menjalankan perintah berikut. Anda seharusnya mendapatkan keluaran teks dalam bahasa Prancis.

# test the function
translate_text("this is a test string to translate")Didukung oleh

Jika Anda mempertimbangkan untuk membagikan aplikasi ini kepada orang lain, sekadar mengirimkan file Python untuk mereka jalankan di command line mungkin cocok untuk sebagian pengguna, terutama yang akrab dengan Python dan alat baris perintah.

Namun, pendekatan ini memiliki keterbatasan. Tidak semua pengguna nyaman menggunakan command line, dan bahkan bagi yang nyaman, menjalankan skrip Python memerlukan lingkungan Python yang telah disiapkan dengan semua dependensi yang diperlukan. Ini bisa merepotkan dan menjadi hambatan bagi pengguna untuk mengakses fungsionalitas aplikasi penerjemahan Anda dengan mudah

Di sinilah membungkus aplikasi Anda dalam FastAPI untuk mengeksposnya sebagai endpoint REST API menjadi solusi yang kuat. Dengan demikian, Anda pada dasarnya membuat antarmuka yang dapat diakses ke aplikasi Anda yang bisa dijangkau melalui internet tanpa mengharuskan pengguna menjalankan skrip Python sendiri. Mereka dapat berinteraksi dengan aplikasi Anda melalui permintaan web sederhana, yang dapat dilakukan dari berbagai platform dan bahasa pemrograman, tidak hanya Python.

Membuat REST API dengan FastAPI mengotomatisasi proses menerima permintaan terjemahan dan mengirimkan hasil terjemahan. Pengguna dapat mengirimkan teks untuk diterjemahkan melalui antarmuka web atau panggilan API terprogram, sehingga jauh lebih mudah dan fleksibel untuk berbagai use case.

Untuk mengonversi fungsi sederhana ini menjadi endpoint API menggunakan FastAPI kita akan memodifikasi kode kita:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import os


os.environ["OPENAI_API_KEY"] = "..."


# Initialize OpenAI client with your API key
client = OpenAI()


# Initialize FastAPI client
app = FastAPI()


# Create class with pydantic BaseModel
class TranslationRequest(BaseModel):
    input_str: str


def translate_text(input_str):
    completion = client.chat.completions.create(
        model="gpt-4-0125-preview",
        messages=[
            {
                "role": "system",
                "content": "You are an expert translator who translates text from english to french and only return translated text",
            },
            {"role": "user", "content": input_str},
        ],
    )


    return completion.choices[0].message.content


@app.post("/translate/")  # This line decorates 'translate' as a POST endpoint
async def translate(request: TranslationRequest):
    try:
        # Call your translation function
        translated_text = translate_text(request.input_str)
        return {"translated_text": translated_text}
    except Exception as e:
        # Handle exceptions or errors during translation
        raise HTTPException(status_code=500, detail=str(e))Didukung oleh

Untuk menjalankan dan menguji API ini secara lokal, jalankan perintah berikut:

uvicorn main:app --reloadDidukung oleh

Di sini, main.py merujuk pada file yang berisi kode Anda. Istilah app menunjuk ke instance aplikasi FastAPI, yang diidentifikasi dalam kode Anda app = FastAPI().

Buka localhost:8000/docs untuk melihat antarmuka UI yang akan terlihat seperti ini:

Klik POST lalu klik try it out, masukkan string teks Anda, dan klik Execute.

Anda akan melihat perintah curl yang dikirim ke API, URL permintaan yang pada titik ini adalah localhost Anda, dan respons server. Kode 200 berarti sukses; di sebelahnya Anda dapat melihat terjemahan bahasa Prancis.

Kesimpulan

Blog ini telah memandu Anda menyiapkan endpoint API menggunakan FastAPI untuk menyajikan aplikasi yang didukung oleh Large Language Models seperti GPT. FastAPI, dengan kinerja dan kemudahan penggunaannya, menyediakan cara langsung untuk membangun API berkinerja tinggi, menjadikannya pilihan ideal bagi pengembang yang ingin mengintegrasikan LLM ke dalam proyek mereka.

Jika Anda ingin mengeksplorasi potensi penuh LLM dengan kursus konseptual unik yang mencakup aplikasi LLM, metodologi pelatihan, pertimbangan etis, dan riset terbaru, lihat kursus gratis Menguasai Large Language Models (LLM) di Datacamp.

Apakah Anda ingin memperluas keterampilan dan perangkat kerja Anda? Pelajari tentang 21 alat Python esensial untuk pengembangan perangkat lunak, web scraping dan pengembangan web, analisis serta visualisasi data, dan pembelajaran mesin.