====== DSPy – programování a optimalizace LLM pipeline ======

//Vytvořeno: **15.7.2026** | Aktualizováno: **~~LASTMOD~~**//

[[https://github.com/stanfordnlp/dspy|DSPy]] je open-source Python framework pro návrh, evaluaci a optimalizaci LLM aplikací. Místo ruční údržby dlouhých promptů se úloha popíše jako strukturovaný program; [[https://dspy.ai/|DSPy]] pak může podle dat a metriky optimalizovat instrukce a few-shot ukázky pro použitý model.

===== Jaký problém DSPy řeší =====

Prompt pro LLM bývá součástí aplikační logiky, ale jako obyčejný text se špatně testuje a udržuje. Při změně modelu, přidání nového typu vstupů nebo nalezení chybného edge case je nutné prompt ručně přepsat a znovu ověřit.

DSPy odděluje tři věci:

  * **definici úlohy** – jaké má vstupy a výstupy;
  * **strategii vykonání** – přímá predikce, reasoning nebo agent s nástroji;
  * **hodnocení kvality** – příklady a metrika, podle které se vybírá lepší varianta programu.

Neznamená to, že prompty zmizí. DSPy z definice úlohy sestaví prompt pro LLM a při optimalizaci hledá jeho účinnější variantu. Hlavní změna je, že prompt už není jediným ručně spravovaným zdrojovým kódem aplikace.

===== Základní stavební bloky =====

==== Signature ====

''Signature'' deklaruje úlohu přes typované vstupy a výstupy. Například klasifikátor support ticketů může mít tento tvar:

<code python>
import dspy
from typing import Literal

class ClassifyTicket(dspy.Signature):
    """Zařaď IT support ticket."""
    ticket: str = dspy.InputField()
    team: Literal["network", "identity", "endpoint", "application"] = dspy.OutputField()
    priority: Literal["low", "medium", "high"] = dspy.OutputField()
    escalation_needed: bool = dspy.OutputField()
</code>

Signature neobsahuje ručně sestavený prompt. Říká pouze, jaký problém se má vyřešit a jak má vypadat odpověď.

==== Modules ====

''Module'' určuje způsob, jakým se signatura vykoná. Pro stejnou úlohu lze použít například přímou predikci, reasoning nebo agentní smyčku s nástroji:

<code python>
classifier = dspy.Predict(ClassifyTicket)
classifier_with_reasoning = dspy.ChainOfThought(ClassifyTicket)
# agent = dspy.ReAct("question -> answer", tools=[search])
</code>

Díky tomu je možné změnit strategii bez změny vstupního a výstupního rozhraní zbytku aplikace.

==== Jazykový model ====

DSPy přistupuje k modelu přes ''dspy.LM''. Konkrétní model a poskytovatel se nastaví odděleně od programu:

<code python>
lm = dspy.LM("openai/gpt-5.4-nano")
dspy.configure(lm=lm)
</code>

Název modelu je příklad z oficiální dokumentace. Produkční konfigurace musí obsahovat odpovídající přístupové údaje a zvolený podporovaný provider.

===== Co se při optimalizaci skutečně mění =====

Základní optimalizace DSPy **neprovádí fine-tuning vah vzdáleného LLM** a nerozpadá prompt na jednotlivá slova. Zachovává použitý model a porovnává varianty programových artefaktů, zejména:

  * instrukce, které DSPy generuje pro danou signaturu;
  * few-shot demonstrace, tedy vybrané příklady vstup → správný výstup;
  * podle zvoleného modulu také strukturu vícekrokového LLM programu.

Optimizer dostane trénovací příklady a metriku. Vytvoří kandidátní varianty instrukcí nebo ukázek, zavolá nad nimi model a vyhodnotí je. Lepší kandidáti se uchovají jako zkompilovaný program.

Například ''GEPA'' lze použít takto:

<code python>
optimizer = dspy.GEPA(metric=semantic_f1, auto="medium")
optimized_rag = optimizer.compile(rag, trainset)
optimized_rag.save("rag-v2.json")
</code>

V tomto příkladu je ''semantic_f1'' metrika kvality a ''trainset'' sada příkladů. Uložený soubor reprezentuje optimalizovanou podobu programu, ne nové váhy modelu.

DSPy podporuje také přístupy jako ''BootstrapFewShot'' a ''MIPROv2'' pro práci s demonstracemi a instrukcemi. Fine-tuning lze do širšího workflow zapojit, ale není nutným ani výchozím mechanismem DSPy.

===== Praktický příklad: třídění IT ticketů =====

Pro klasifikátor ticketů je potřeba nejprve připravit historické příklady se správným týmem, prioritou a rozhodnutím o eskalaci. Příklady se rozdělí alespoň na trénovací a nezávislou validační sadu.

Metrika může vyžadovat shodu všech výstupů:

<code python>
def ticket_metric(example, prediction, trace=None):
    return (
        example.team == prediction.team
        and example.priority == prediction.priority
        and example.escalation_needed == prediction.escalation_needed
    )
</code>

Výchozí ''dspy.Predict'' se nejprve vyhodnotí na validační sadě. Potom optimizer hledá vhodnější instrukci a demonstrace. Může tak například zjistit, že zmínka o MFA má vést k týmu ''identity'', zatímco porucha po výměně notebooku může patřit pod ''endpoint''.

Přínos není v tom, že DSPy zaručí správné zařazení. Přínos je v opakovatelném postupu: místo ručního hádání, co přidat do promptu, se každá změna porovná vůči stejné metrice a stejným datům.

===== Doporučený workflow =====

  - Definovat úlohu jako ''Signature'' a začít jednoduchým modulem, typicky ''dspy.Predict''.
  - Připravit reprezentativní příklady a explicitní metriku kvality.
  - Změřit baseline na validační sadě.
  - Spustit optimizer nad trénovacími daty.
  - Vyhodnotit optimalizovaný program na oddělené holdout sadě, ne pouze na datech použitých při optimalizaci.
  - Porovnat kvalitu, cenu volání modelu a latenci; teprve potom uložit a nasadit vybranou variantu.

===== Kdy je DSPy přínosný =====

DSPy se hodí pro úlohy s jasným vstupem, výstupem a ověřitelnou kvalitou: klasifikaci, extrakci strukturovaných dat, RAG odpovědi, LLM judge nebo konkrétní krok agentního workflow. Užitečný je také při migraci mezi modely, pokud je potřeba ověřit, zda levnější nebo jiný model stále dosahuje požadované kvality.

Naopak nepřináší velkou hodnotu pro jednorázový prompt nebo problém bez dat a bez metriky. V takovém případě optimizer nemá podle čeho rozlišit lepší variantu a přidává jen další abstrakci a náklady na LLM volání.

===== Omezení =====

Kvalita optimalizace je přímo závislá na kvalitě metriky a reprezentativnosti dat. Špatně navržená metrika může optimalizovat nežádoucí chování nebo vést k přizpůsobení příliš úzké sadě příkladů. Hodnocení proto patří na oddělená data a musí zahrnovat i provozní požadavky, zejména cenu a latenci.

DSPy také nenahrazuje integrační a orchestration vrstvu aplikace. Pro řízení stavu, napojení systémů, UI nebo rozsáhlé agentní workflow může být jednou součástí řešení vedle běžného Pythonu či jiného orchestration frameworku.

===== Zdroje =====

  * [[https://github.com/stanfordnlp/dspy|DSPy – GitHub repozitář]]
  * [[https://dspy.ai/|DSPy – oficiální dokumentace]]
  * [[https://arxiv.org/abs/2310.03714|DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines]]
  * [[https://arxiv.org/abs/2507.19457|GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning]]