Przejdź do głównej treści
Polski— Wybierz język
Menu

Potok wielonarzędziowy

Lekcja 13 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Orkiestracja narzędzi w sekwencji
  2. Architektura potoku
  3. Przykład: potok wywiadu konkurencyjnego
  4. Wykonanie potoku
  5. Łączenie narzędzi serwerowych i klienckich w potoku
  6. Wzorzec: rozproszenie / scalenie (fan-out / fan-in)
  7. Obsługa błędów w potoku
  8. Kluczowe wnioski

Orkiestracja narzędzi w sekwencji

Agent pogodowy z poprzedniej lekcji korzystał z niezależnych narzędzi. W potoku wielonarzędziowym wyniki jednego narzędzia zasilają kolejne wywołanie. Model automatycznie orkiestruje sekwencję – Twoim zadaniem jest dostarczenie narzędzi i wykonanie wywołań.

Architektura potoku

Typowy potok遵循 następujący schemat:

Wyszukiwanie → Analiza → Działanie → Powiadomienie

Każdy krok generuje dane zużywane przez kolejny. Model obsługuje tę orkiestrację w sposób naturalny dzięki kontekstowi rozmowy.

Przykład: potok wywiadu konkurencyjnego

Wyobraź sobie potok, który monitoruje ceny konkurencji i generuje raport:

tools = [
    {
        "type": "function",
        "function": {
            "name": "scrape_competitor_prices",
            "description": "Retrieve current prices from a competitor "
                          "for a list of products. Returns an array "
                          "of {product, price, availability}.",
            "parameters": {
                "type": "object",
                "properties": {
                    "competitor": {
                        "type": "string",
                        "description": "Competitor name"
                    },
                    "products": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "List of products to check"
                    }
                },
                "required": ["competitor", "products"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "compare_with_our_prices",
            "description": "Compare competitor prices with our prices. "
                          "Returns percentage gaps and adjustment "
                          "recommendations.",
            "parameters": {
                "type": "object",
                "properties": {
                    "competitor_prices": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "product": {"type": "string"},
                                "price": {"type": "number"}
                            }
                        }
                    }
                },
                "required": ["competitor_prices"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "generate_report",
            "description": "Generate a PDF report with the benchmark "
                          "analysis results. Returns the report URL.",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "data": {"type": "object"},
                    "format": {
                        "type": "string",
                        "enum": ["pdf", "csv", "json"]
                    }
                },
                "required": ["title", "data"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "send_notification",
            "description": "Send an email or Slack notification "
                          "with a summary and a link to the report.",
            "parameters": {
                "type": "object",
                "properties": {
                    "channel": {
                        "type": "string",
                        "enum": ["email", "slack"]
                    },
                    "recipient": {"type": "string"},
                    "message": {"type": "string"},
                    "attachment_url": {"type": "string"}
                },
                "required": ["channel", "recipient", "message"]
            }
        }
    }
]

Wykonanie potoku

Gdy użytkownik poprosi: „Przeanalizuj ceny CompetitorX dla naszych 5 najlepszych produktów i wyślij raport do zespołu sprzedaży“, model przeprowadzi orkiestrację:

Tura 1 : scrape_competitor_prices(competitor="CompetitorX", products=[...])
Tura 2 : compare_with_our_prices(competitor_prices=[wyniki z tury 1])
Tura 3 : generate_report(title="Monitorowanie cen CompetitorX", data={...})
Tura 4 : send_notification(channel="slack", recipient="#sales", ...)

Każda tura wykorzystuje wyniki z poprzedniej. Model w sposób naturalny przekazuje dane z jednego narzędzia do następnego.

Łączenie narzędzi serwerowych i klienckich w potoku

Najpotężniejsze potoki łączą narzędzia serwerowe i klienckie:

tools = [
    {"type": "web_search"},  # Serwer: wyszukiwanie w sieci
    {
        "type": "function",
        "function": {
            "name": "extract_data",
            "description": "Extract structured data from raw text",
            "parameters": { ... }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "save_to_crm",
            "description": "Save extracted data to the CRM",
            "parameters": { ... }
        }
    }
]

Przepływ: model wykonuje wyszukiwanie w sieci (automatycznie po stronie serwera), następnie wywołuje Twoją funkcję ekstrakcji (strona klienta), a na końcu zapisuje dane w CRM (strona klienta).

Wzorzec: rozproszenie / scalenie (fan-out / fan-in)

Niektóre potoki wymagają wzorca rozproszenia (wiele wywołań równoległych), po którym następuje scalenie (agregacja wyników):

         ┌→ scrape_site_A ─┐
Żądanie ─┤→ scrape_site_B ─┤→ aggregate_results → generate_report
         └→ scrape_site_C ─┘

Model obsługuje to w sposób naturalny poprzez wywołania równoległe:

Tura 1 : [scrape_site_A, scrape_site_B, scrape_site_C]  (równolegle)
Tura 2 : aggregate_results(data=[wynik_A, wynik_B, wynik_C])
Tura 3 : generate_report(aggregated_data={...})

Obsługa błędów w potoku

Solidny potok obsługuje błędy na każdym etapie:

def execute_with_retry(name, args, max_retries=2):
    for attempt in range(max_retries + 1):
        try:
            result = execute_function(name, args)
            if "error" not in result:
                return result
        except Exception:
            pass

        if attempt < max_retries:
            time.sleep(1)  # Czekaj przed ponowną próbą

    return {
        "error": f"Failed after {max_retries + 1} attempts",
        "function": name,
        "partial_data": None
    }

Gdy krok się nie powiedzie, model może:

  • Ponowić próbę ze skorygowanymi parametrami
  • Pominąć krok i kontynuować z częściowymi danymi
  • Poinformować użytkownika i poprosić o instrukcje

Kluczowe wnioski

  • Potok wielonarzędziowy łączy wyniki jednego narzędzia z kolejnym
  • Model automatycznie orkiestruje sekwencję dzięki kontekstowi
  • Wzorzec rozproszenia/scalenia łączy wywołania równoległe z agregacją
  • Łącz narzędzia serwerowe (web_search) i klienckie (Twoje funkcje), aby tworzyć potoki hybrydowe
  • Obsługuj błędy na każdym etapie, stosując ponawianie prób i rozwiązania zapasowe
  • Każde narzędzie w potoku musi mieć jasną, pojedynczą odpowiedzialność