Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Osvědčené postupy a další kroky

Lekce 18 z 18 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Co jsi probral
  2. Navrhování agentů, kteří obstojí
  3. Zpracování chyb
  4. Vidění toho, co se děje
  5. Testování směrování
  6. Referenční architektura
  7. Kam dál
  8. Klíčové poznatky
  9. Ověř si své znalosti

Co jsi probral

Prošel jsi celé rozhraní API Mistral Agents. Než se ponoříme do postupů pro nasazení do produkce, shrňme si to, protože každá část tohoto kurzu navazuje na tu předchozí.

První tři lekce položily základy: agent AI je autonomní systém se smyčkou vnímání-akce; API stojí na třech objektech – Agent, Conversation a Entry; a co odlišuje agenta od chatbota, je perzistence, nástroje a předávání úloh (handoffs). Lekce 4 až 7 učinily tyto objekty použitelnými: vytváření a konfigurace agentů pomocí client.beta.agents.create(), udržování perzistentních konverzací s conversations.start() a conversations.append() a používání přímého režimu bez agenta při prototypování, kdy perzistence nepřináší hodnotu.

Lekce 8 až 11 přidaly nové schopnosti. web_search ti poskytuje přístup k aktuálním informacím s automatickými citacemi; code_interpreter spouští Python v izolovaném prostředí (sandbox), což agentovi dává přesné výsledky tam, kde by samotný model pouze aproximoval; image_generation vytváří vizuály na základě textových promptů; document_library přináší integrované RAG pro tvé vlastní dokumenty. Lekce 12 až 16 pak ukázaly spolupráci více agentů: předávání úloh (handoffs) přenáší řízení z jednoho agenta na druhého, referenční architektura páruje centrální směrovač se specialisty, serverový režim automatizuje procesy, zatímco klientský režim tě udržuje ve smyčce, a neomezené řetězení se dělí na lineární, hvězdicové a hybridní vzory. Nakonec lekce 17 vše završila ochrannými zábranami (guardrails), principem nejmenších oprávnění a moderací na straně vstupu.

Jedna věta vystihuje celý kurz: jeden agent, jedna odpovědnost, jeden popis, který říká, kdy ho zavolat. Následující kontrast činí rozdíl hmatatelným.

# DOBŘE — specializovaný agent s přesným popisem
agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="invoice-processor",
    description="Processes invoices: extracts amounts, dates, vendors.",
    instructions="Extract invoice information into structured JSON.",
    tools=[{"type": "document_library", "library_ids": [invoices_lib.id]}]
)

# ŠPATNĚ — obecný, vágní agent
agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="helper",
    description="A helpful agent.",
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}, {"type": "image_generation"}]
)

Druhý agent selže hned dvakrát. Žádný směrovač nebude vědět, kdy mu předat požadavek, protože „užitečný agent“ nepopisuje žádnou konkrétní situaci. A když už bude povolán, jeho tři nástroje mu umožní hledat na webu něco, co měl vypočítat, nebo ilustrovat něco, co měl analyzovat.

Zpracování chyb

Síťová volání dříve či později selžou. Opakování s exponenciálním backoffem pohltí přechodné incidenty, aniž by se momentální zpomalení změnilo ve viditelný výpadek.

import time

def safe_conversation(agent_id, query, max_retries=3):
    """Conversation with error handling and retry."""
    for attempt in range(max_retries):
        try:
            response = client.beta.conversations.start(
                agent_id=agent_id,
                inputs=query
            )
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)  # Exponential backoff
    return None

Exponenciální backoff – jedna sekunda, pak dvě, pak čtyři – odlišuje civilizované opakování od bombardování služby, která už tak má problémy. Všimni si také, že poslední pokus znovu vyvolá výjimku místo návratu None: tvůj volající kód potřebuje vědět, že operace selhala.

Vidění toho, co se děje

V produkčním prostředí se workflow s více agenty, které nemůžeš sledovat, stane nemožným k ladění. Klientský režim ti poskytuje přesně ty háčky, které potřebuješ.

import logging
import time

logger = logging.getLogger("agents")

def monitored_conversation(agent_id, query):
    """Conversation with monitoring."""
    start = time.time()

    response = client.beta.conversations.start(
        agent_id=agent_id,
        inputs=query,
        handoff_execution="client"
    )

    handoff_count = 0
    tool_count = 0

    for entry in response.outputs:
        if entry.type == "agent.handoff":
            handoff_count += 1
            logger.info(f"Handoff #{handoff_count}: → {entry.next_agent_id}")
        elif entry.type == "tool.execution":
            tool_count += 1
            logger.info(f"Tool #{tool_count}: {entry.tool_name}")

    duration = time.time() - start
    logger.info(f"Finished in {duration:.1f}s — {handoff_count} handoffs, {tool_count} tools")

    return response

Tyto dva čítače mají větší hodnotu, než napovídá jejich jednoduchost: odchylka v průměrném počtu předání úloh signalizuje váhající směrovač; nárůst volání nástrojů ukazuje na nákladné dotazy.

Kontrola nákladů se pak redukuje na konkrétní rozhodnutí. Sleduj počet tokenů na konverzaci, protože to je skutečná fakturační jednotka. Používej mistral-medium-latest všude tam, kde mistral-large-latest nic nepřidává – první úroveň podpory je učebnicovým příkladem. Omez max_tokens v completion_args, abys předešel nekonečným odpovědím na jednoduché otázky, a vypni ukládání pomocí store=False, když není vyžadována perzistence.

Testování směrování

Testuj systém s více agenty jako jakoukoli ústřednu: předkládej mu případy, u kterých znáš očekávané cílové místo, a ověř, kam dorazí.

def test_agent_routing():
    """Verifies that the router distributes correctly."""
    test_cases = [
        ("What is the price of Bitcoin?", "web-search-agent"),
        ("Calculate 25 * 48", "calculator-agent"),
        ("Summarize this document", "doc-agent"),
    ]

    for query, expected_agent_name in test_cases:
        response = client.beta.conversations.start(
            agent_id=router.id,
            inputs=query,
            handoff_execution="client"
        )

        for entry in response.outputs:
            if entry.type == "agent.handoff":
                target = client.beta.agents.get(agent_id=entry.next_agent_id)
                assert target.name == expected_agent_name, \
                    f"Incorrect routing for '{ query}': {target.name} instead of {expected_agent_name}"

Tuto sadu testů buduj postupem času: každý špatně směrovaný požadavek, který zachytíš v produkci, se stane dalším řádkem v test_cases, a budeš vědět, že přepsání popisu opraví cílený případ, aniž bys rozbil jiný.

Referenční architektura

Pro produkční projekt zde je doporučená architektura:

Application
    │
    ▼
Moderator Agent (filters requests)
    │
    ▼
Router Agent (distributes to specialists)
    ├── Search Agent (web_search)
    ├── Analysis Agent (code_interpreter)
    ├── Documents Agent (document_library)
    └── Creation Agent (image_generation)
    │
    ▼
Logging + Monitoring + Alerting

Spojuje vše z tohoto kurzu: moderátor filtruje před jakoukoli exekucí, směrovač řídí, aniž by sám odpovídal, každý specialista nese jeden nástroj a jednu odpovědnost a pozorování obklopuje celý systém.

Kam dál

Čtyři směry rozšiřují to, co nyní umíš. Function calling ti umožňuje vytvářet vlastní nástroje nad rámec vestavěných: volat obchodní API, dotazovat databázi, spouštět interní službu. MCP Servers integrují Model Context Protocol, který standardizuje způsob vystavování nástrojů. Strukturované výstupy vynucují odpovědi do schématu JSON, což mění vše, když výstup agenta napájí jiný systém místo lidského čtenáře. Nakonec, streaming vrací odpovědi v reálném čase místo jednoho bloku – rozhodující u dlouhých řetězců, kde se tiché čekání stává nepříjemným.

Tento další krok doprovázejí tři zdroje: oficiální dokumentace na docs.mistral.ai/agents, kuchařky (cookbooks) od Mistralu, které poskytují kompletní příklady implementace, a Reference API, která podrobně dokumentuje každý koncový bod.

Klíčové poznatky

  • Specializuj své agenty – jeden agent = jedna odpovědnost
  • Monitoruj – loguj každé předání úlohy a provedení nástroje
  • Testuj – ověřuj směrování a odpovědi každého agenta
  • Zabezpeč – ochranné zábrany, princip nejmenších oprávnění, moderace na vstupu
  • Optimalizuj náklady – model přiměřené velikosti, max_tokens, store=False, kdykoli je to možné
  • Mistral Agents jsou v beta verzi – sleduj změny v API

Ověř si své znalosti

Agenti, vestavěné nástroje, předávání úloh: má API Agents ještě nějaká slepá místa?

1. Kdy je agent nezbytný – a kdy stačí chatbot?

Odpověď: Agent je opodstatněný, když potřebuješ nástroje, perzistenci a vícekroková rozhodnutí; pro jednoduché otázky a odpovědi stačí standardní konverzace – architektura se řídí potřebou.

2. Co spravují perzistentní konverzace v API Agents?

Odpověď: Historii na straně Mistralu: konverzaci pokračuješ pomocí jejího ID, aniž bys musel znovu odesílat celý kontext – stav se stává službou.

3. Vyjmenuj dostupné vestavěné nástroje a jejich použití.

Odpověď: web_search (informace v reálném čase), code_interpreter (spouštění Pythonu), image_generation (tvorba obrázků), document_library (dotazy a odpovědi na tvé soubory) – připravené schopnosti, žádná implementace nutná.

4. Jak funguje systém s více agenty s předáváním úloh?

Odpověď: Směrovač kvalifikuje požadavek a předá jej kompetentnímu specializovanému agentovi; každý agent zůstává jednoduchý, orchestrace zajišťuje pokrytí – a předávání úloh se řetězí do hloubky.

5. Jak zabezpečíš agenty v produkci?

Odpověď: Pomocí ochranných zábran na vstupech/výstupech, úzce vymezených nástrojů, sledovatelnosti akcí a lidské validace u rozhodnutí s vysokými sázkami – autonomie se získává prostřednictvím kontroly.

Specializovaní agenti, vestavěné nástroje, směrování, ochranné zábrany: kompletní architektura se vejde do čtyř slov – a tento kurz tě provedl stavbou každého z nich.