OpenAI a Python: streamovanie odpovedí, obrázky a systémové prompty

Pri generovaní dlhších odpovedí je užitočné odpoveď streamovať, teda zobrazovať ju postupne, ako prichádza, namiesto čakania na kompletnú odpoveď. To sa dosiahne nastavením parametra stream=True. Následne iterujeme cez odpoveď a vypisujeme jednotlivé časti (chunky). Streamovanie výrazne zlepšuje používateľský zážitok, pretože používateľ vidí, že model pracuje, a nemusí čakať na kompletné dokončenie generovania, čo môže pri dlhších textoch trvať aj niekoľko desiatok sekúnd.

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ.get("OPENROUTER_API_KEY"),
)

# Enable streaming in the completion request
stream = client.chat.completions.create(
    model="z-ai/glm-4.5-air:free",
    messages=[
        {
            "role": "user",
            "content": "Is Pluto a planet?"
        }
    ],
    stream=True  # Enable streaming
)

# Process the stream in real-time
print("Streaming response:")
for chunk in stream:
    # Check if the chunk contains content
    if chunk.choices[0].delta.content is not None:
        # Print the content chunk without a newline
        print(chunk.choices[0].delta.content, end="", flush=True)

# Add a final newline for clean formatting
print()

Volanie metódy client.chat.completions.create obsahuje parameter stream=True, ktorý spôsobí, že metóda nevráti celú odpoveď naraz, ale vráti objekt stream, cez ktorý je možné iterovať.

V cykle for prechádzame jednotlivé časti odpovede. Každá z nich obsahuje malý kúsok vygenerovaného textu. Tento text sa nachádza v chunk.choices[0].delta.content. Pomocou print(..., end="", flush=True) vypisujeme jednotlivé časti na obrazovku bez toho, aby sme za každou časťou pridali nový riadok, a zároveň zabezpečíme, že sa text vypíše okamžite.

Dôležité je si uvedomiť, že pri streamovaní nečakáme na celú odpoveď, ale spracúvame ju po častiach. To je efektívne nielen z pohľadu používateľského zážitku, ale aj z hľadiska pamäte, pretože nemusíme držať celú odpoveď v pamäti naraz.

Viacťahová konverzácia

Viacťahová konverzácia (multi-turn conversation) je kľúčovou vlastnosťou moderných modelov, ktorá umožňuje prirodzenú a koherentnú komunikáciu medzi používateľom a modelom. Na rozdiel od jednoduchých jednorazových otázok a odpovedí pri viacťahovej konverzácii si model zachováva pamäť predchádzajúcich správ a používa ich na generovanie relevantnejších a kontextovo vhodnejších odpovedí. Táto schopnosť je rozhodujúca pre udržanie plynulosti rozhovoru a poskytovanie personalizovaných reakcií, ktoré zohľadňujú celú históriu interakcie.

Základným princípom viacťahovej konverzácie je správa histórie správ v poli messages. História konverzácie sa buduje postupne – každá nová správa sa pridá na koniec pola messages, čím sa vytvára kompletný záznam celej interakcie. Model potom používa túto históriu na generovanie odpovedí, ktoré sú konzistentné s predchádzajúcim priebehom rozhovoru. Táto metóda umožňuje modelom udržiavať kontext, pamätať si dôležité informácie a poskytovať relevantnejšie odpovede v priebehu dlhších konverzácií.

Je však dôležité uvedomiť si aj potenciálne obmedzenia. S rastúcou dĺžkou konverzácie sa zvyšuje aj veľkosť histórie správ, čo môže viesť k vyšším nákladom na API volania a dlhšiemu času spracovania. Niektoré modely majú aj obmedzenia na maximálnu dĺžku kontextu (context window), čo znamená, že po dosiahnutí určitého počtu správ sa môžu stratiť informácie z počiatočných častí konverzácie.

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ.get("OPENROUTER_API_KEY"),
)

# Initialize messages for multi-turn conversation
messages = [
    {
        "role": "user",
        "content": "What is the capital of France? Answer in one sentence."
    }
]

# First turn: Ask about France
completion = client.chat.completions.create(
    model="z-ai/glm-4.5-air:free",
    messages=messages
)

# Get and store the response
france_response = completion.choices[0].message.content
messages.append({
    "role": "assistant",
    "content": france_response
})

print("First question response:", france_response)

# Second turn: Ask about Slovakia
messages.append({
    "role": "user",
    "content": "And of Slovakia?"
})

completion = client.chat.completions.create(
    model="z-ai/glm-4.5-air:free",
    messages=messages
)

# Print the final response
print("Second question response:", completion.choices[0].message.content)

V tomto príklade vidíme praktickú implementáciu viacťahovej konverzácie. Začneme s inicializáciou poľa messages obsahujúceho prvú otázku od používateľa. Po získaní odpovede od modelu túto odpoveď pridáme do histórie s rolou assistant. V druhom ťahu pridáme ďalšiu otázku od používateľa a pošleme celú históriu správ modelu. Model teraz má prístup k celej konverzácii a môže generovať správnu odpoveď, ktorá zohľadňuje predchádzajúci kontext.

py test.py
First question response:
"The capital of France is Paris."
Second question response: "The capital of Slovakia is Bratislava."

Práca s obrázkami

Knižnica OpenAI umožňuje prácu s obrázkami, vrátane ich analýzy a generovania. Na tieto úlohy je potrebné použiť modely schopné spracovať vizuálny vstup (vision models), ako sú napríklad GPT-4o alebo v tomto príklade použitý meta-llama/llama-4-maverick-17b-128e-instruct.

Príklad demonštruje, ako pomocou knižnice OpenAI analyzovať obrázok prostredníctvom služby Groq. Modelu sa odošle požiadavka obsahujúca URL adresu obrázka a textovú výzvu. Následne model vráti textový popis obsahu obrázka.

Pri použití modelu schopného spracovať vizuálny vstup je potrebné štruktúrovať obsah správy ako zoznam, ktorý obsahuje časti typu text a image_url.

Groq je špecializovaná platforma pre inferenciu umelej inteligencie (vykonávanie natrénovaných modelov), ktorá dosahuje extrémne vysokú rýchlosť a nízku latenciu vďaka vlastným čipom. (Nemýliť si to s Grok modelom od xAI Elona Muska.)

Jej stratégia je zameraná na akceleráciu výhradne open-source veľkých jazykových modelov, ako sú Llama, Mixtral či GPT-OSS, čím podporuje komunitu a transparentnosť v AI. Pre vývojárov a testovacie projekty ponúka Groq štedrú bezplatnú úroveň prístupu k svojmu API, ktorá má nastavené denné a minútové limity na počet požiadaviek a tokenov. Tieto limity umožňujú používateľom bezplatne testovať rýchlosť platformy, kým sa rozhodnú pre platené programy.

Popis obrázka

V nasledujúcom príklade je obrázok poskytnutý ako externá URL adresa.

from openai import OpenAI
import os

API_KEY = os.getenv("GROQ_API_KEY")
client = OpenAI(api_key=API_KEY, base_url="https://api.groq.com/openai/v1")


completion = client.chat.completions.create(
    model="meta-llama/llama-4-maverick-17b-128e-instruct",  # Vision-capable model
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in detail."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://pbs.twimg.com/media/CR9k1K1WwAAakqD.jpg"
                    },
                },
            ],
        }
    ],
)
print(completion.choices[0].message.content)

Model vráti textovú odpoveď s podrobným popisom obsahu obrázka. Táto odpoveď zvyčajne identifikuje kľúčové objekty, ich vlastnosti (farby, tvary, textúry) a vzájomné vzťahy. V závislosti od komplexnosti obrázka a špecifickosti textovej výzvy (promptu) môže popis obsahovať aj informácie o kontexte, atmosfére alebo možných interpretáciách scény.

Alternatívne je možné obrázok zakódovať do formátu Data URI a poslať ho priamo v tele požiadavky. Nasledujúci príklad načíta obrázok z lokálneho disku, zakóduje ho do formátu base64, vytvorí z neho Data URI a odošle ho modelu na analýzu.

from openai import OpenAI
import os
import base64

API_KEY = os.getenv("GROQ_API_KEY")
client = OpenAI(api_key=API_KEY, base_url="https://api.groq.com/openai/v1")

# Read and encode image from disk
with open("sid.jpg", "rb") as image_file:
    base64_string = base64.b64encode(image_file.read()).decode('utf-8')

image_url = f"data:image/jpeg;base64,{base64_string}"

completion = client.chat.completions.create(
    extra_body={},
    model="meta-llama/llama-4-maverick-17b-128e-instruct",  # Vision-capable model
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in detail."},
                {"type": "image_url", "image_url": {"url": image_url}}
            ]
        }
    ]
)
print(completion.choices[0].message.content)

Použitie Data URI vkladá dáta obrázka priamo do textového reťazca požiadavky, čím sa odstraňuje závislosť na externom súbore. Model meta-llama/llama-4-maverick-17b-128e-instruct dokáže porozumieť a popísať obrázky poskytnuté v oboch formátoch (URL aj Data URI).

Generovanie obrázkov

Tento príklad demonštruje, ako generovať obrázky pomocou OpenAI API. Nie je jednoduché nájsť modely generujúce obrázky, preto sa tentokrát pripojíme k OpenAI službe. Na vytvorenie obrázka na základe textového popisu sa používa model openai/dall-e-3.

Pre OpenAI nie je potrebné explicitne nastaviť API kľúč, ak je uložený v systémovej premennej OPENAI_API_KEY.

import openai
import os
import requests

client = openai.OpenAI()
# client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.images.generate(
    model="dall-e-3",
    prompt="An old monk in a cell, writing a book by candlelight, highly detailed, intricate, dramatic lighting, artstation, octane render",
    size="1024x1024",
    quality="standard",
    n=1, # number of images to generate
)

image_url = response.data[0].url
print(f"Generated image: {image_url}")

# Download and save the image
image_data = requests.get(image_url).content
with open("monk_writing.png", "wb") as f:
    f.write(image_data)
print("Image saved as monk_writing.png")

Kľúčové parametre pre generovanie obrázkov zahŕňajú prompt (textový popis obrázka), size (rozmery), quality (kvalita) a n (počet generovaných obrázkov).

Najprv sa obrázok vygeneruje na základe zadaného promptu. Následne sa získa URL adresa vygenerovaného obrázka z odpovede API. Pomocou knižnice requests sa obrázok stiahne a uloží na disk.

Transkripcia zvuku

Tento príklad ukazuje, ako prepísať lokálny zvukový súbor na text. Príklad načíta zvukový súbor v binárnom režime a odošle ho na API pre prepis zvuku (transkripciu) s použitím modelu whisper-large-v3. Voliteľný parameter prompt umožňuje usmerniť formát alebo obsah výstupu. Výsledný text je dostupný v atribúte transcription.text.

import openai
import os

API_KEY = os.getenv("GROQ_API_KEY")
client = openai.OpenAI(api_key=API_KEY, base_url="https://api.groq.com/openai/v1")

def transcribe_file(path):
    with open(path, "rb") as audio_file:
        transcription = client.audio.transcriptions.create(
            model="whisper-large-v3",
            file=audio_file,
            prompt="Give us only the text of the fable."
        )
    return transcription.text

result = transcribe_file("aesop_fox_grapes.mp3")
print(result)

Funkciu transcribe_file je možné použiť na prepis lokálneho zvukového súboru zadaním cesty k nemu. Hlavné parametre sú model (je možné vybrať z dostupných modelov Whisper), file (zvukový súbor otvorený v binárnom režime) a voliteľný prompt na usmernenie prepisu.

Príklad s použitím knižnice Gradio

Tento príklad demonštruje komplexnú integráciu knižnice OpenAI s OpenRouter API prostredníctvom moderného používateľského rozhrania Gradio. Gradio je knižnica na vytváranie interaktívnych webových aplikácií pre strojové učenie. Umožňuje rýchlo vytvárať a zdieľať aplikácie s minimálnym úsilím. V súčasnosti ide o veľmi populárny nástroj na rýchle prototypovanie a zdieľanie ML modelov cez webové rozhranie.

import os
import httpx
import openai
import gradio as gr

OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
SYSTEM_PROMPT = "You are a helpful AI assistant."
# Default network timeout in seconds
DEFAULT_TIMEOUT_S = 30

# Initialize OpenAI client with OpenRouter base URL
client = openai.AsyncOpenAI(api_key=OPENROUTER_API_KEY,
                            base_url="https://openrouter.ai/api/v1")


# This example demonstrates how to set up a Gradio chat interface
# that interacts with OpenRouter's chat completions API via OpenAI library.


async def call_openai_stream(model, messages, temperature=0.7):
    """
    Call OpenRouter chat completions with streaming via OpenAI library.
    """
    stream = await client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=temperature,
        stream=True,
    )
    async for chunk in stream:
        if chunk.choices and chunk.choices[0].delta.content:
            yield chunk.choices[0].delta.content


def _history_to_messages(history, system_prompt):
    """
    Convert Gradio Chatbot history to OpenAI messages format with a system prompt.

    Supports Chatbot(type="messages") history [{"role": "...", "content": ...}, ...].
    """
    messages = []
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})

    if not history:
        return messages

    # History is a list of dicts with role and content
    for m in history:
        role = m.get("role")
        content = m.get("content")
        if role in ("user", "assistant", "system"):
            messages.append({"role": role, "content": content})
        else:
            # Skip unknown roles to be safe
            continue
    return messages


with gr.Blocks(title="OpenRouter Gradio Chat", theme=gr.themes.Ocean()) as demo:
    gr.Markdown("# OpenRouter Chat")
    with gr.Row():
        with gr.Column(scale=3):
            model_dropdown = gr.Dropdown(
                label="Model (loaded from OpenRouter)",
                choices=["Loading..."],
                value="Loading...",
                interactive=True,
            )
            temperature = gr.Slider(
                minimum=0.0,
                maximum=2.0,
                step=0.1,
                value=0.7,
                label="Temperature",
            )
        with gr.Column(scale=4):
            system_prompt_box = gr.Textbox(
                label="System Prompt",
                value=SYSTEM_PROMPT,
                lines=3,
                placeholder="You are a helpful AI assistant.",
            )

    chat = gr.Chatbot(
        label="Conversation",
        height=500,
        type="messages",
    )

    # Custom aligned input row with Send and Terminate buttons
    # Using compact row to keep controls on one line; scales ensure alignment.
    with gr.Row(variant="compact"):
        user_input = gr.Textbox(
            placeholder="Ask me anything...",
            lines=2,
            scale=8,
            show_label=False,
            container=True,
        )
        with gr.Column(scale=1):
            send_btn = gr.Button("Send", variant="primary")
        with gr.Column(scale=1):
            stop_btn = gr.Button("Terminate", variant="stop")

    # Wire up events: Enter on textbox or Send button triggers respond_fn.
    # Gradio Chatbot(type="messages") requires returning a list of {"role","content"} dicts.
    async def _respond(message, history, model, system_prompt, temperature):
        if model == "Loading...":
            # Models not loaded yet, yield current history unchanged
            yield history or []
            return

        # history is a list of {"role": "...", "content": ...} dicts from Chatbot(type="messages")
        # Build role/content messages including system
        messages = _history_to_messages(history or [], system_prompt or SYSTEM_PROMPT)
        if message and message.strip():
            messages.append({"role": "user", "content": message})

        # Initialize the assistant message in the chat history
        # We'll update this progressively as we receive streaming chunks
        initial_messages = messages.copy()
        assistant_message = {"role": "assistant", "content": ""}
        initial_messages.append(assistant_message)

        # Call model with streaming
        stream_gen = call_openai_stream(
            model=model, messages=messages, temperature=temperature
        )

        # Process the streaming response
        full_response = ""
        async for chunk in stream_gen:
            full_response += chunk
            # Update the assistant message content with the accumulated response
            updated_messages = initial_messages[:-1]  # Remove the last message
            updated_messages.append(
                {"role": "assistant", "content": full_response}
            )  # Add updated message
            yield updated_messages  # Yield the updated messages for real-time display

    send_event = send_btn.click(
        _respond,
        inputs=[user_input, chat, model_dropdown, system_prompt_box, temperature],
        outputs=chat,
        queue=True,
        api_name=False,
    )
    # Submit on Shift+Enter in textbox (since it's multiline)
    submit_event = user_input.submit(
        _respond,
        inputs=[user_input, chat, model_dropdown, system_prompt_box, temperature],
        outputs=chat,
        queue=True,
        api_name=False,
    )

    stop_btn.click(
        None,  # No action on stop button click
        None,  # No additional input
        None,  # No output
        cancels=[send_event, submit_event],
    )

    async def fetch_models():
        """
        Fetch the available model IDs from OpenRouter.
        Returns a list of model identifiers.
        """
        if not OPENROUTER_API_KEY:
            # no key found: exit with error
            print("OPENROUTER_API_KEY not set, exiting...")
            exit(1)
        url = f"https://openrouter.ai/api/v1/models"
        async with httpx.AsyncClient(timeout=DEFAULT_TIMEOUT_S) as client:
            r = await client.get(url, headers={
                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
                "Content-Type": "application/json",
            })
            r.raise_for_status()
            data = r.json()
        models = []
        # Extract model IDs from the response
        for m in data.get("data", []):
            mid = m.get("id")
            if isinstance(mid, str):
                models.append(mid)
        # Sort models alphabetically for easier selection
        return sorted(models)

    async def load_models():
        """
        Update the model dropdown options by fetching from OpenRouter API.
        This is called on demo launch to populate models.
        """
        try:
            models = await fetch_models()
            if models:
                # Default to a reasonable commonly-available model if present
                default = (
                    "anthropic/claude-3.5-haiku"
                    if "anthropic/claude-3.5-haiku" in models
                    else models[0] if models else "No models found"
                )
                print(f"Fetched models: {len(models)} models, default: {default}")
                return gr.Dropdown(choices=models, value=default)
            else:
                return gr.Dropdown(choices=["No models found"], value="No models found")
        except Exception as e:
            error_msg = f"Error: {str(e)}"
            print(error_msg)
            return gr.Dropdown(choices=[error_msg], value=error_msg)

    demo.load(load_models, inputs=None, outputs=model_dropdown)

if __name__ == "__main__":
    # 0.0.0.0 allows LAN access; change as preferred
    demo.queue().launch(server_name="localhost", server_port=7861)

Použitím openai.AsyncOpenAI s parametrom base_url="https://openrouter.ai/api/v1" vytvárame asynchrónneho klienta, ktorý komunikuje s OpenRouter API. Funkcia call_openai_stream využíva asynchrónne streamovanie pomocou stream=True, čo umožňuje zobrazovať odpoveď modelu v reálnom čase po častiach. Gradio Chatbot s parametrom type="messages" používa moderný formát správ ako zoznam objektov s atribútmi role (úloha) a content (obsah). Funkcia _history_to_messages konvertuje túto históriu do formátu, ktorý očakáva OpenAI API, vrátane pridania systémového promptu na začiatok konverzácie.

Aplikácia asynchrónne načíta zoznam dostupných modelov z OpenRouter API pri spustení pomocou funkcie load_models() registrovanej cez demo.load(). Pomocná funkcia fetch_models() používa knižnicu httpx na priame volanie REST API endpointu /models, zatiaľ čo load_models() spracováva výsledky, riadi chybové stavy a vracia aktualizovaný dropdown komponent. Modely sú zoradené abecedne a dropdown sa automaticky aktualizuje s predvoleným modelom anthropic/claude-3.5-haiku (ak je dostupný), inak sa vyberie prvý dostupný model.

Rozhranie obsahuje niekoľko interaktívnych prvkov: model dropdown pre výber zo stoviek dostupných modelov na OpenRouter, temperature slider na nastavenie kreativity modelu (od 0.0 pre deterministické odpovede až po 2.0 pre veľmi kreatívne), system prompt textbox na konfiguráciu správania AI asistenta, chat rozhranie s históriou konverzácie a podporou streamovania, ako aj „Send“ a „Terminate“ tlačidlá na odoslanie správy alebo zrušenie bežiacej generácie.

Funkcia _respond je asynchrónna a využíva generátory ( yield) na postupné aktualizovanie chat histórie počas streamovania. Tlačidlo „Terminate“ využíva parameter cancels=[send_event, submit_event], ktorý umožňuje okamžité zrušenie prebiehajúcej generácie odpovede. Kód obsahuje kontrolu if model == "Loading...", ktorá zabezpečuje, že používateľ nemôže odoslať správu predtým, než sa načítajú dostupné modely, čím sa predchádza chybám typu „No models provided“.

Metóda demo.queue().launch() spúšťa webový server na porte 7861. Parameter queue=True umožňuje správne fungovanie asynchrónnych operácií a streamovania. Aplikácia je dostupná na adrese http://localhost:7861.

Systémové prompty a zmena osoby

Systémové prompty sú základným pilierom efektívneho využívania LLM modelov. Ide o špeciálne inštrukcie, ktoré sa posielajú modelu pred začiatkom konverzácie a ktoré definujú jeho správanie, osobnosť, tón, kontext a obmedzenia. Systémový prompt je ako „režisérska inštrukcia“ pre AI model – určuje, akú rolu má model hrať, ako má komunikovať a aké pravidlá má dodržiavať počas celej interakcie s používateľom.

Bez správneho systémového promptu sa model správa ako generický AI asistent, ktorý síce vie odpovedať na otázky, ale nemá žiadny špecifický kontext, osobnosť alebo špecializáciu. Systémové prompty umožňujú transformovať všeobecný AI model na špecializovaného experta v konkrétnej doméne – či už ide o lekárskeho poradcu, právneho experta, programátorského asistenta alebo dokonca o fiktívnu postavu z knihy.

Existuje niekoľko základných typov systémových promptov, každý navrhnutý pre špecifický účel:

• Inštrukčné prompty – definujú, ako má model vykonávať konkrétne úlohy
• Behaviorálne prompty – určujú osobnosť, tón a komunikačný štýl
• Kontextové prompty – poskytujú pozadie a špecializáciu v konkrétnej oblasti
• Obmedzujúce prompty – stanovujú pravidlá a hranice správania
• Kompozičné prompty – kombinujú viaceré typy pre komplexné scenáre

Efektívny systémový prompt musí byť jasný, konkrétny a úplný. Vyhnite sa vágnemu jazyku a nejasnostiam – model bude interpretovať váš prompt presne tak, ako ste ho napísali. Tu je niekoľko kľúčových princípov:

• Jasnosť a presnosť – používajte jednoznačné, zrozumiteľné inštrukcie
• Špecifickosť – čím konkrétnejší prompt, tým lepšie výsledky
• Kompletnosť – zahrňte všetky dôležité informácie a obmedzenia
• Konzistentnosť – zachovávajte jednotný štýl a tón
• Flexibilita – ponechajte priestor pre rôzne typy otázok

Pozrime sa na konkrétne príklady, ako rôzne typy promptov ovplyvňujú správanie modelu. Klasický, inštrukčný prompt:

You are a Python programming tutor. When students ask for help:
- Explain concepts step by step
- Provide code examples
- Point out common mistakes
- Suggest best practices
- Ask clarifying questions when needed

Behaviorálny prompt:

You are a friendly and patient kindergarten teacher. Always:
- Use simple, age-appropriate language
- Be encouraging and positive
- Use analogies and examples from children's lives
- Break down complex ideas into tiny steps
- Celebrate small victories and progress

Kontextový prompt:

You are an expert financial advisor specializing in retirement planning for Slovak citizens.
You have deep knowledge of:
- Slovak pension system and regulations
- European financial markets
- Tax implications for retirement savings
- Investment strategies suitable for conservative investors
- Local banking and insurance products

Always consider the Slovak economic context and provide advice in Slovak language.

Obmedzujúci prompt:

You are a medical information assistant. IMPORTANT RESTRICTIONS:
- Never provide specific medical diagnoses
- Always recommend consulting qualified healthcare professionals
- Only provide general health information and wellness tips
- If users describe serious symptoms, urge immediate medical attention
- Do not suggest specific treatments or medications
- Stay within general health education boundaries

Jedna z najvýkonnejších funkcií systémových promptov je schopnosť dynamicky meniť osobnosť alebo rolu modelu uprostred konverzácie. To otvára dvere pre sofistikované interaktívne scenáre, kde sa model môže prispôsobiť potrebám používateľa alebo kontextu rozhovoru.

Pozrime sa na pokročilejší príklad, ktorý demonštruje rôzne aspekty systémových promptov:

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ.get("OPENROUTER_API_KEY"),
)

def demonstrate_system_prompts():
    """Showcase different types of system prompts and their effects."""

    user_question = "How do I optimize my Python code for better performance?"

    # Educational and patient teacher
    teacher_prompt = """
    You are a patient and encouraging computer science professor.
    Your teaching style:
    - Break down complex topics into digestible parts
    - Use analogies and real-world examples
    - Encourage questions and curiosity
    - Build understanding step by step
    - Celebrate learning milestones
    - Be supportive of all skill levels
    """

    # Concise and direct senior engineer
    engineer_prompt = """
    You are a senior software engineer with 15 years of experience.
    Your communication style:
    - Be direct and to the point
    - Focus on practical solutions
    - Use technical terminology appropriately
    - Provide actionable advice
    - Prioritize performance and efficiency
    - Don't waste words on unnecessary explanations
    """

    # Humorous and engaging tech enthusiast
    enthusiast_prompt = """
    You are a passionate tech enthusiast who loves programming.
    Your personality:
    - Use humor and relatable analogies
    - Be enthusiastic and energetic
    - Share personal anecdotes from coding experience
    - Make complex topics fun and accessible
    - Use emojis occasionally to add personality
    - Encourage experimentation and learning through doing
    """

    # Academic and rigorous researcher
    researcher_prompt = """
    You are a computer science researcher and professor.
    Your approach:
    - Provide thorough, academically rigorous explanations
    - Cite relevant algorithms and data structures
    - Discuss time/space complexity analysis
    - Reference academic papers and best practices
    - Encourage critical thinking about trade-offs
    - Focus on fundamental computer science principles
    """

    prompts = [
        ("Teacher", teacher_prompt),
        ("Engineer", engineer_prompt),
        ("Enthusiast", enthusiast_prompt),
        ("Researcher", researcher_prompt)
    ]

    for persona_name, prompt in prompts:
        print(f"\n=== {persona_name} ===")

        response = client.chat.completions.create(
            model="anthropic/claude-3-haiku",
            messages=[
                {"role": "system", "content": prompt},
                {"role": "user", "content": user_question}
            ]
        )

        print(response.choices[0].message.content)

if __name__ == "__main__":
    demonstrate_system_prompts()

V tomto príklade definujeme štyri rôzne systémové prompty, z ktorých každý predstavuje inú osobnosť alebo rolu: trpezlivý učiteľ, skúsený inžinier, technický nadšenec a akademický výskumník. Každý prompt obsahuje špecifické inštrukcie týkajúce sa štýlu komunikácie, tónu a prístupu k vysvetľovaniu optimalizácie Python kódu. Následne pre každý prompt odošleme rovnakú otázku používateľa a vytlačíme odpoveď.

Veľkú moc systémových promptov som si uvedomil dávnejšie náhodou, keď som požiadal model Grok o pomoc pri migrácii webovej stránky od lokálneho poskytovateľa na DigitalOcean. Model mi nielenže poskytol technické inštrukcie, ale aj aktívne kládol doplňujúce otázky a požadoval výstupy z príkazov, aby mohol presnejšie poradiť a overiť stav. Najprv som to pripisoval modelu Grok; až neskôr som si uvedomil, že to bolo vďaka tomu, ako som napísal systémový prompt.

Všetky príklady z článku a mnohé ďalšie sú dostupné na GitHub repozitári github.com/janbodnar/Python-AI-Skolenie. V ďalšom prokračovaní si povieme viac o používaní nástrojov.