0Pricing
AI Agents · Lekcja

Zwracanie wyników do modelu

Formatuj dane wyjściowe narzędzi jako komunikaty z rolą tool, aby model mógł je odczytać i kontynuować rozmowę.

Zwracanie wyników do modelu to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Wiadomość z wynikiem narzędzia

Po uruchomieniu narzędzia należy poinformować model o wyniku za pomocą wiadomości narzędzia:

messages.append({
    'role': 'tool',
    'tool_call_id': tool_call.id,    # MUST match the assistant's tool_call.id
    'content': json.dumps(result)
})

Zawartość powinna być ciągiem znaków

OpenAI oczekuje, że content będzie ciągiem znaków. Obiekty należy serializować za pomocą json.dumps:

# Bad — will error
messages.append({'role': 'tool', 'tool_call_id': id, 'content': {'temp': 18}})

# Good
messages.append({'role': 'tool', 'tool_call_id': id, 'content': '{"temp": 18}'})

Format Anthropic

Anthropic używa bloku zawartości wewnątrz wiadomości użytkownika:

messages.append({
    'role': 'user',
    'content': [{
        'type': 'tool_result',
        'tool_use_id': 'toolu_abc',
        'content': json.dumps(result)
    }]
})

Zwracanie błędów

Jeśli narzędzie zakończyło się niepowodzeniem, należy zwrócić błąd — nie wolno udawać, że operacja się powiodła. Model może podjąć próbę odzyskania:

try:
    result = run_tool(...)
    content = json.dumps({'ok': True, 'data': result})
except Exception as e:
    content = json.dumps({'ok': False, 'error': str(e)})

messages.append({'role': 'tool', 'tool_call_id': id, 'content': content})

Schemat wielu wyników

W przypadku równoległych wywołań narzędzi należy dodać każdy wynik wraz z pasującym identyfikatorem:

for tc in message.tool_calls:
    result = dispatch(tc)
    messages.append({
        'role': 'tool',
        'tool_call_id': tc.id,
        'content': json.dumps(result)
    })

Duże dane wyjściowe: podsumowanie

Jeśli narzędzie zwraca 100 KB kodu HTML, przesłanie całości do modelu marnuje tokeny i rozprasza jego uwagę. Najpierw należy utworzyć podsumowanie lub obciąć dane:

def truncate(text, max_chars=4000):
    if len(text) <= max_chars:
        return text
    return text[:max_chars] + f'\n...[truncated, {len(text)-max_chars} more chars]'

sample = "x" * 4500
result = truncate(sample, max_chars=50)
print(result)

Zawsze ten sam schemat

Nawet gdy wyniki się różnią (sukces / błąd / nie znaleziono), należy zachować stabilny schemat danych wyjściowych. Model działa bardziej niezawodnie przy spójnej strukturze:

from typing import TypedDict, Literal, Optional, Any

class ToolResult(TypedDict):
    status: Literal['ok', 'not_found', 'error']
    data: Optional[Any]
    error: Optional[str]

def make_result(status, data=None, error=None) -> ToolResult:
    return {'status': status, 'data': data, 'error': error}

print(make_result('ok', data={'temp': 72}))
print(make_result('not_found', error='city not found'))

Dodawanie wskazówek w metadanych

Można ułatwić modelowi interpretację wyników, dodając wskazówki do zawartości:

content = json.dumps({
    'data': rows,
    'note': 'Returned 50 rows (most recent first). There may be more matches.'
})

Dane binarne

Nie należy umieszczać dużych danych binarnych w wiadomościach narzędzi w formacie base64. Zamiast tego należy zapisać je w magazynie i zwrócić adres URL lub identyfikator:

result = {
    'image_path': '/tmp/chart-abc.png',
    'thumbnail_url': 'https://...',
    'caption': 'Sales by quarter, 2024'
}
for k, v in result.items():
    print(f"{k}: {v}")

Ponowne wywołanie modelu

Po dodaniu wszystkich wyników narzędzi należy ponownie wywołać model — albo utworzy on odpowiedź końcową, albo wywoła kolejne narzędzia:

class Msg:
    def __init__(self, tool_calls=None, content=None):
        self.tool_calls = tool_calls or []
        self.content = content

class ToolCall:
    def __init__(self, name, args):
        self.name = name
        self.args = args

def call_model(messages, tools):
    if len(messages) < 4:
        return Msg(tool_calls=[ToolCall('get_weather', {'city': 'Paris'})])
    return Msg(content='It is sunny in Paris.')

messages = [{'role': 'user', 'content': 'Weather in Paris?'}]
tools = ['get_weather']
message = call_model(messages, tools)

while message.tool_calls:
    for tc in message.tool_calls:
        result = f'Result of {tc.name}({tc.args})'
        messages.append({'role': 'tool', 'name': tc.name, 'content': result})
        print('Tool call:', tc.name, '->', result)
    message = call_model(messages, tools)

print('Final answer:', message.content)

Audytowanie wyników narzędzi

W celach diagnostycznych należy rejestrować każdą trójkę (tool_call_id, args, result). Gdy agent zrobi coś dziwnego, dziennik wyników narzędzi jest pierwszym miejscem, które należy sprawdzić.

Format wyniku narzędzia

Do czego odnosi się tool_call_id w wiadomości narzędzia?

Podsumowanie

Znają już Państwo cały cykl wywołania narzędzia. Następny kurs: pamięć — trzeci filar agentów.

Często zadawane pytania

Czy lekcja „Zwracanie wyników do modelu” jest bezpłatna?

Tak — pełny tekst „Zwracanie wyników do modelu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „Zwracanie wyników do modelu”?

Formatuj dane wyjściowe narzędzi jako komunikaty z rolą tool, aby model mógł je odczytać i kontynuować rozmowę. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Zwracanie wyników do modelu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?

Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Jak działa wywoływanie funkcji
  2. Definiowanie schematów narzędzi (JSON Schema)
  3. Wybór narzędzi w czasie działania
  4. Zwracanie wyników do modelu
← Powrót do AI Agents