Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Meta-pozivanje: ustvarjanje optimalnih pozivov

Lekcija 5 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Meta-pozivanje: ustvarjanje optimalnih pozivov
  2. Načelo
  3. Ustvarjanje iz specifikacij
  4. Izboljšanje obstoječega poziva
  5. Ustvarjanje različic za primerjavo
  6. Sestava cevovoda
  7. Česa meta-pozivanje ne more storiti namesto tebe
  8. Ključne ugotovitve

Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra temperature in top_p sta sprejeta le pri prizadevanju za razmišljanje (reasoning effort) vrednosti none, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določiti reasoning={"effort": "none"} (API za odzive) ali reasoning_effort="none" (dopolnitve klepeta). Viri: Uporaba GPT-6 · GPT-5.6 Terra.

Meta-pozivanje: ustvarjanje optimalnih pozivov

Meta-pozivanje vključuje uporabo velikega jezikovnega modela (LLM) za ustvarjanje ali izboljševanje pozivov. Namesto da bi vsako navodilo napisal ročno, opišeš nalogo in od modela zahtevaš, naj ustvari optimalen poziv. Prihranek časa je takojšen, vendar je prava prednost drugje: ta tehnika razkrije formulacije, na katere morda nikoli ne bi pomislil, saj razvijalci vedno pišejo pozive z istimi refleksi in slepimi pegami.

Načelo

Dober poziv je program, napisan v naravnem jeziku. Kot pri vsakem programu je včasih bolj učinkovito, da ga generiraš, namesto da ga tipkaš ročno – tudi migracij podatkovne baze ne pišeš znak za znakom. Meta-pozivanje izkorišča dejstvo, da se je model med usposabljanjem srečal z ogromno količino pozivov in razprav o tem, kaj jih dela učinkovite. Spodnji primer zahteva sistemski poziv za razvrščanje vstopnic za podporo strankam. Pozoren bodi na dve podrobnosti: specifikacija je natančna vse do vrednosti kategorij, zadnja vrstica pa zahteva surov izhod brez spremnega komentarja, kar zagotavlja, da je rezultat neposredno uporaben v kodi.

from openai import OpenAI

client = OpenAI()

meta_prompt = """You are an expert in prompt engineering.

Generate an optimized system prompt for the following task:
- Objective: Classify customer support tickets
- Categories: bug, feature_request, question, billing
- Output: JSON with "category", "priority" (1-5), "summary"
- Constraints: Response in French, max 100 tokens

The prompt must include:
1. A clear role
2. The categories with classification criteria
3. The exact output format with an example
4. Edge cases (ambiguous ticket, out-of-category)

Return ONLY the system prompt, with no explanation."""

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature requires effort none
    input=meta_prompt,
    temperature=0.7
)

generated_prompt = response.output_text
print(generated_prompt)

Ustvarjanje iz specifikacij

Prvi vzorec industrializira tisto, kar si pravkar naredil ročno: svoje zahteve opišeš kot funkcionalne omejitve, model pa ustvari ustrezni poziv. Če meta-poziv oviješ v funkcijo, dobiš ponovno uporaben generator za vsako nalogo v svoji aplikaciji. Stranski učinek je pomemben: pozivi, ki jih napiše pet različnih razvijalcev, prenehajo imeti pet različnih slogov, kar bistveno poenostavi pregled kode.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Generates a system prompt from specifications."""
    spec = f"""Generate a system prompt for this task:

Objective: {objective}

Constraints:
{chr(10).join(f'- {c}' for c in constraints)}

Expected output format:
{output_format}

Include a concrete input/output example.
Return only the prompt, with no commentary."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=spec,
        temperature=0.5
    )
    return response.output_text

Izboljšanje obstoječega poziva

Drugi vzorec začne s pozivom, ki je že v proizvodnji, in opaženo napako na terenu. Namesto da bi ga popolnoma prepisal – s čimer tvegaš, da boš pokvaril tisto, kar je delovalo popolnoma – priložiš trenutni poziv skupaj s natančnim opisom težave: „včasih odgovori v angleščini” ali „izmišlja si številke naročil, ko manjka referenca”. Navodilo „ohrani tisto, kar deluje” je tu odločilno. Brez njega bi model spontano preoblikoval celotno stvar in ti izročil popolnoma nov poziv, ki ga ne bi več razumel.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Improves an existing prompt based on feedback."""
    meta = f"""Here is a system prompt that has a problem:

--- CURRENT PROMPT ---
{current_prompt}
--- END ---

Observed problem: {problem}

Rewrite this prompt to fix this problem.
Keep what works; modify only what is necessary.
Return only the improved prompt."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=meta,
        temperature=0.3
    )
    return response.output_text

Ustvarjanje različic za primerjavo

Tretji vzorec ustvari več različic istega poziva: cilj ostaja enak, fraziranje in struktura pa se razlikujeta. To je surovina za testiranje A/B, ki ga bomo obravnavali v lekciji 15; brez različic preprosto nimaš ničesar za primerjavo. Visoka temperatura tukaj ni pomota: služi prav temu, da ustvari raznolikost med različicami, medtem ko bi ti nizka temperatura dala tri skoraj identične preoblikbe.

def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
    """Generates n variants of a prompt."""
    meta = f"""Here is a system prompt:

{base_prompt}

Generate {n} variants of this prompt that:
- Keep the same objective
- Use different phrasing
- Vary the structure (lists vs. paragraphs, order of instructions)

Separate each variant with "---VARIANT---"."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=meta,
        temperature=0.9
    )
    return response.output_text.split("---VARIANT---")

Sestava cevovoda

Ti trije gradniki se naravno povežejo: iz cilja ustvariš poziv, proizvedeš različice, nato pa vsako različico izvedeš na reprezentativnem testnem nizu, da jih oceniš na podlagi dokazov in ne ocen.

def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
    """Complete meta-prompting pipeline."""

    # 1. Generate 3 variants
    variants = generate_variants(
        generate_prompt(objective, [], "free text"), n=3
    )

    # 2. Test each variant
    scores = []
    for i, prompt in enumerate(variants):
        results = []
        for test in tests:
            response = client.responses.create(
                model="gpt-5.6-terra",
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions=prompt.strip(),
                input=test,
                temperature=0.2
            )
            results.append(response.output_text)
        scores.append((i, results))

    # 3. Evaluate (adapt to your criteria)
    print("Compare the results and select the best variant.")
    return variants, scores

Česa meta-pozivanje ne more storiti namesto tebe

Model ima močno težnjo k prekomerni optimizaciji: poziv, ki ga vrne, je pogosto preveč obsežen ali preozko umerjen na primere, ki si jih priskrbel, zaradi česar se obnaša slabo pri nekoliko drugačnih primerih. Človeški pregled je zato pred vsako uvedbo obvezen, že zato, da preveriš, ali niso bile mimogrede izumljena kakšna poslovna pravila – model, ki dopolnjuje nepopolno specifikacijo, to vedno stori v dobri veri, včasih pa napačno. Pazite tudi na stroške: vsaka iteracija porabi žetone, neomejena zanka za izboljševanje pa se lahko vleče dolgo, ne da bi se kdaj konvergirala. Največje število iteracij nastavi v svoji kodi, ne v svoji osebni disciplini.

Če želiš obvladati to tehniko, vzemi resnično nalogo iz svojega področja, napiši njeno popolno specifikacijo (cilj, omejitve, format), ustvari tri različice, jih preizkusi na petih primerih iz svojega proizvodnega okolja in nato najboljšo ročno izpopolni. Skoraj vedno je prav ta končni ročni dotist tisti, ki naredi razliko med solidnim pozivom in takim, ki je pripravljen za proizvodnjo.

Ključne ugotovitve

  • Meta-pozivanje uporablja LLM kot generator pozivov
  • Trije vzorci: ustvarjanje, iterativno izboljševanje, različice
  • Vedno preveri ustvarjene pozive s konkretnimi testi
  • Združi samodejno ustvarjanje z ročnim prilagajanjem
  • Nastavi omejitve, da se izogneš dragim iteracijskim zankam