Een LLM‑applicatie aanbieden als API-endpoint met FastAPI in Python

Introductie

Large Language Models (LLM’s) staan vooraan in de ontwikkeling van Generatieve AI en veranderen de manier waarop machines mensachtige tekst begrijpen en genereren. LLM-modellen zoals GPT, Claude, LLaMA, Mistral, enz. drijven innovaties aan in chatbots, contentcreatie en meer, en bieden ongekende mogelijkheden voor het verwerken en genereren van natuurlijke taal.

De echte waarde van LLM’s gaat echter verder dan hun ruwe rekenkracht; toegankelijkheid is cruciaal. API’s (Application Programming Interfaces) fungeren als bruggen waarmee uiteenlopende applicaties de kracht van LLM’s kunnen benutten. Ze stellen developers in staat geavanceerde taalbegrip- en generatiefunctionaliteit in hun apps te integreren, van eenvoudige tekstanalyse tot complexe dialoogsysteemem.

In deze tutorial bouwen we een eenvoudige Python-applicatie met het OpenAI GPT‑model en bieden we die aan via een API-endpoint dat is ontwikkeld met het FastAPI-framework in Python.

Large Language Models

Large Language Models (LLM’s) zijn geavanceerde AI-systemen die zijn ontworpen om mensachtige tekst te begrijpen en te genereren. Deze modellen zijn getraind op enorme hoeveelheden data, waardoor ze complexe patronen herkennen, taalfinesses begrijpen en samenhangende antwoorden kunnen genereren.

LLM’s kunnen diverse taaltaken uitvoeren, zoals vertaling, tekstaanvulling, samenvatten en zelfs conversaties. GPT is een voorbeeld van een LLM.

In dit artikel bouwen we een eenvoudige Python-applicatie met de GPT API van OpenAI en maken we vervolgens een REST-endpoint voor onze applicatie met het FastAPI-framework in Python.

LLM is een type Generatieve AI. Wil je meer leren over Generatieve AI en hoe het je creativiteit kan versterken, bekijk dan onze blogposts over Generatieve AI gebruiken om je creativiteit te boosten en onze podcast Inside the Generative AI Revolution.

Je kunt je ook inschrijven voor onze komende cursus Large Language Models Concepts.

Wat is een API?

Application Programming Interface (API) is de ruggengraat van softwarecommunicatie en maakt het mogelijk dat verschillende systemen, applicaties en apparaten naadloos met elkaar interacteren en data delen. Het fungeert als een set regels en protocollen waarmee software-entiteiten kunnen communiceren, en biedt een vooraf gedefinieerde manier waarop de ene applicatie functionaliteit of data van een andere kan benutten zonder de interne werking te hoeven kennen.

API’s zijn alomtegenwoordig in het digitale ecosysteem van vandaag. Ze drijven webservices, mobiele apps en cloud computing aan, faciliteren communicatie tussen applicaties en integratie van diensten van derden. Ze vereenvoudigen ontwikkeling door bouwstenen te bieden die developers kunnen gebruiken om sneller nieuwe software te maken, waardoor functionaliteit en gebruikerservaring worden verbeterd zonder vanaf nul te beginnen.

Met API’s kunnen developers hun applicaties uitbreiden op manieren die anders complex of onmogelijk zouden zijn. Daarom zijn ze een cruciaal onderdeel van moderne softwareontwikkeling.

Beeldbron

Ben je geïnteresseerd in de engineeringkant van het uitrollen van machinelearningmodellen in de praktijk, bekijk dan deze uitgebreide gids over Machine Learning, Pipelines, Deployment en MLOps. Je kunt ook de gratis cursus Introductie tot API op Datacamp volgen.

FastAPI

FastAPI is een Python-framework voor het bouwen van high-performance API’s. De opmars is te danken aan de snelheid, het gebruiksgemak en de compatibiliteit met asynchrone programmering. FastAPI helpt developers LLM-functionaliteit als API-endpoints bloot te stellen, waardoor het eenvoudiger wordt om AI‑gestuurde services uit te rollen, te beheren en op te schalen.

FastAPI valt op door performance en efficiëntie. Het benut moderne Python-features zoals type hints en asynchrone programmering en biedt snelheidsverbeteringen die kunnen concurreren met NodeJS en zelfs Go.

Dat performancevoordeel is cruciaal voor applicaties die realtime dataverwerking en gelijktijdige requests vereisen, zoals interfaces met LLM’s. De mogelijkheid om inkomende data automatisch te valideren en responses te serialiseren vermindert boilerplate en maakt API-ontwikkeling schoner en overzichtelijker.

De automatische documentatiefeature, gebaseerd op standaarden als OpenAPI, biedt developers en gebruikers duidelijke, interactieve API-documentatie en vereenvoudigt integratie en testen verder.

Voorbeeld van API-creatie:

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}Mogelijk gemaakt door

Deze code creëert een eenvoudige webserver met FastAPI. De server reageert op twee soorten webverzoeken: één die de gebruiker begroet met "Hello World" bij een bezoek aan de homepage ("/"), en een andere die de ID van een item en een optionele queryparameter "q" toont wanneer de gebruiker een specifieke itempagina bezoekt ("/items/{item_id}"). De item‑ID is verplicht en moet een integer zijn, terwijl de queryparameter "q" optioneel is en een string kan zijn of ontbreken.

Start de FastAPI-server met:

End-to-end-applicatie bouwen in Python

Het hoofddoel van deze blog is laten zien hoe je snel REST API-endpoints bouwt voor je LLM‑applicaties. We maken een eenvoudige Python‑applicatie (slechts één functie) die de OpenAI GPT‑4 API gebruikt en Engelse tekst naar Frans vertaalt. Deze applicatie heeft maar één functie: 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.contentMogelijk gemaakt door

Deze functie neemt één input van de gebruiker en geeft die rechtstreeks door aan het OpenAI GPT‑4‑model. Er is een systeemprompt om de context te definiëren en de userprompt is de tekst die we van de gebruiker ontvangen in input_str.

Je kunt deze functie testen door het volgende uit te voeren. Je zou Franse tekst terug moeten krijgen.

# test the function
translate_text("this is a test string to translate")Mogelijk gemaakt door

Als je overweegt deze applicatie met anderen te delen, kan het doorsturen van het Python‑bestand zodat zij het via de command line draaien voor sommige gebruikers werken, vooral voor wie bekend is met Python en commandlinetools.

Maar deze aanpak heeft beperkingen. Niet iedereen voelt zich comfortabel met de command line en zelfs dan vereist het draaien van een Python‑script een Python‑omgeving met alle benodigde dependencies. Dat kan omslachtig zijn en vormt een drempel om je vertaalapplicatie eenvoudig te gebruiken.

Daarom is je applicatie inpakken in FastAPI om die als REST API‑endpoint bloot te stellen een krachtige oplossing. Zo creëer je een toegankelijke interface die via internet te bereiken is, zonder dat gebruikers zelf Python‑scripts hoeven te draaien. Ze kunnen met je applicatie interacteren via eenvoudige webverzoeken, vanuit allerlei platforms en programmeertalen, niet alleen Python.

Een REST API maken met FastAPI automatiseert het ontvangen van vertaalverzoeken en het terugsturen van vertalingen. Gebruikers kunnen tekst aanleveren via een webinterface of een programmatische API‑call, wat het veel makkelijker en flexibeler maakt voor verschillende use-cases.

Om deze eenvoudige functie om te zetten in een API-endpoint met FastAPI passen we onze code aan:

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))Mogelijk gemaakt door

Om deze API lokaal te draaien en te testen, voer je simpelweg het volgende commando uit:

uvicorn main:app --reloadMogelijk gemaakt door

Hier verwijst main.py naar het bestand met je code. De term app verwijst naar de FastAPI‑applicatie‑instance, die in je code is gedefinieerd als app = FastAPI().

Ga naar localhost:8000/docs om een UI te zien die er zo uit zou moeten zien:

Klik op POST, klik vervolgens op Try it out, voer je tekststring in en klik op Execute.

Je zou een curl‑commando moeten zien dat naar de API is gestuurd, de request‑URL (op dit moment je localhost) en de serverrespons. Code 200 betekent succes; daarnaast zie je de Franse vertaling.

Conclusie

In deze blog hebben we stap voor stap een API‑endpoint opgezet met FastAPI om applicaties te bedienen die draaien op Large Language Models zoals GPT. FastAPI biedt met zijn performance en gebruiksgemak een rechttoe‑rechtaan manier om high‑performance API’s te bouwen en is daarmee een ideale keuze voor developers die LLM’s in hun projecten willen integreren.

Wil je het volledige potentieel van LLM’s ontdekken met een unieke, conceptuele cursus over LLM‑applicaties, trainingsmethodologieën, ethische overwegingen en het nieuwste onderzoek, bekijk dan deze gratis cursus Mastering Large Language Models (LLMs) op Datacamp.

Wil je je skillset en toolkit verbreden? Lees dan meer over de 21 essentiële Python‑tools voor softwareontwikkeling, webscraping en -development, data-analyse en visualisatie, en machine learning.