PL ▾
Pobierz klucz API

Dokumentacja LangChain Agentic AI: Narzędzia i tryb JSON

Większość dokumentacji LangChain Agentic AI zakłada klasę modelu własnego dostawcy, ale dowolny endpoint kompatybilny z OpenAI działa z ChatOpenAI po ustawieniu base URL. Ten poradnik łączy LangChain z tym API i buduje agenta z wywoływaniem narzędzi krok po kroku.

Zaktualizowano

Kluczowe punkty

  • Użyj ChatOpenAI z base_url ustawionym na to API i modelem ustawionym na uncensored.
  • Wywoływanie funkcji i tryb JSON są obsługiwane, więc bind_tools i response_format działają zgodnie z dokumentacją.
  • Ogranicz pętle agentów, zwaliduj argumenty narzędzi i utrzymuj max_concurrency na poziomie 8 lub mniej przy pełnym kluczu.
  • Strumieniowanie przez SSE zwraca użycie tokenów na końcu, co pomaga śledzić koszt każdego uruchomienia agenta.
Robotyczne ramię przemieszczające kostki przez stacje narzędzi na pętli, reprezentujące pętlę agenta LangChain

Czego potrzebujesz przed rozpoczęciem

Jeśli czytasz dokumentację LangChain Agentic AI i zastanawiasz się, co się zmienia, gdy model nie pochodzi od dostawcy z przykładów, odpowiedź brzmi: bardzo mało. Agent w LangChain to pętla: model czyta rozmowę, decyduje, czy wywołać narzędzie, Twój kod uruchamia narzędzie, a wynik wraca do modelu, aż wygeneruje ostateczną odpowiedź. Endpoint modelu musi tylko obsługiwać chat completions z wywoływaniem narzędzi, a to API to robi.

Potrzebujesz trzech rzeczy: klucza API ze strony kluczy, Pythona 3.10 lub nowszego oraz poniższych pakietów. Base URL to https://api.unlimitedaiapi.com/v1, a ID modelu to uncensored. To jeden model o otwartych wagach uruchamiany przez niezależnego dostawcę, więc nie ma listy modeli do wyboru; GET /v1/models zwraca go do odkrywania przez klienta.

pip install -U langchain langchain-openai
export UNLIMITED_API_KEY="your-key-here"

Krok 1: podłącz ChatOpenAI do endpointu

Klasa LangChain ChatOpenAI przyjmuje niestandardowy base_url. Wszystko inne pozostaje bez zmian, w tym invoke, stream, batch i warianty async.

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0.2,
)

print(llm.invoke("Reply with one short sentence.").content)

Jeśli to wypisze zdanie, uwierzytelnianie, routing i nazwa modelu są poprawne. Autoryzacja to standardowy nagłówek Authorization: Bearer, który klasa dodaje za Ciebie. Typowym błędem jest pominięcie /v1 w base URL, co zwykle powoduje niepowodzenie pierwszego wywołania.

Krok 2: zdefiniuj narzędzia i powiąż je

Narzędzia to zwykłe funkcje Pythona z docstringiem. Docstring i podpowiedzi typów stają się schematem, jaki widzi model, więc pisz je tak, jakbyś wyjaśniał funkcję nowemu koledze.

import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def get_order_status(order_id: str) -> str:
    '''Look up the status of an order by its ID, for example A100.'''
    return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)
llm_with_tools = llm.bind_tools([get_order_status])

ai = llm_with_tools.invoke("Where is order A100?")
print(ai.tool_calls)

Wypisana lista zawiera wywołanie z nazwą get_order_status i argumentami takimi jak {"order_id": "A100"}. Pod spodem LangChain wysyła Twoją funkcję jako wpis w tablicy tools żądania chat completions, a API obsługuje tools, tool_choice i strumieniowane tool_calls. Aby wymusić wywołanie narzędzia, przekaż tool_choice do bind_tools.

Dlaczego temperatura jest niska

Agenci łączą wiele wywołań modelu, więc jeden niepoprawny argument może zepsuć uruchomienie. Temperatura od 0 do 0,2 sprawia, że wybór narzędzi jest bardziej powtarzalny. Podnieś ją tylko na kroku generowania ostatecznej odpowiedzi, jeśli chcesz bardziej zróżnicowaną treść.

Krok 3: uruchom pętlę agenta

Napisanie pętli samodzielnie zajmuje piętnaście linii i pokazuje dokładnie, co dzieje się na każdym kroku, co pomaga, gdy coś pójdzie nie tak. Wyniki narzędzi wracają do modelu jako obiekty ToolMessage, które stają się wiadomościami role: "tool" w przesyłanych danych.

import os
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def get_order_status(order_id: str) -> str:
    '''Look up the status of an order by its ID, for example A100.'''
    return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)
tools = {"get_order_status": get_order_status}
llm_with_tools = llm.bind_tools(list(tools.values()))

messages = [HumanMessage("Where is order A100, and what about A101?")]
for _ in range(5):                      # hard cap on loop length
    ai = llm_with_tools.invoke(messages)
    messages.append(ai)
    if not ai.tool_calls:
        break
    for call in ai.tool_calls:
        result = tools[call["name"]].invoke(call["args"])
        messages.append(ToolMessage(content=str(result), tool_call_id=call["id"]))

print(ai.content)

Zwróć uwagę na range(5). Agent bez limitu kroków może zapętlić się w nieskończoność przy mylących wynikach narzędzia, a każdy przebieg kosztuje tokeny wejściowe za całą dotychczasową rozmowę. Pięć to rozsądny limit dla prostych zadań; podnieś go świadomie.

Używanie gotowego helpera agenta

Nowsze wersje LangChain zawierają helper, który uruchamia tę pętlę za Ciebie. Nazwa i ścieżka importu zmieniały się między wydaniami, więc potwierdź je w dokumentacji zainstalowanej wersji. W obecnej linii 1.x wygląda to tak:

import os
from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def get_order_status(order_id: str) -> str:
    '''Look up the status of an order by its ID, for example A100.'''
    return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)

agent = create_agent(llm, tools=[get_order_status], system_prompt="You are a concise support assistant.")
result = agent.invoke({"messages": [{"role": "user", "content": "Where is order A100?"}]})
print(result["messages"][-1].content)

Użyj helpera, gdy chcesz standardowego wzorca, a ręcznie napisaną pętlę, gdy potrzebujesz niestandardowych reguł zatrzymania, logowania na każdym kroku lub wyników narzędzi, które chcesz przefiltrować, zanim zobaczy je model.

Wyjście strukturalne w trybie JSON

Agenci często muszą przekazywać dane do innego kodu, np. plan, klasyfikację lub listę wyodrębnionych pól. Tryb JSON wymusza odpowiedź jako poprawny obiekt JSON. W LangChain możesz go przekazać przez bind:

import json
import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)
json_llm = llm.bind(response_format={"type": "json_object"})

msg = json_llm.invoke(
    "Extract the city and country from: 'I moved to Lyon, France last spring.' "
    "Answer as JSON with the keys city and country."
)
print(json.loads(msg.content))

Wspomnij słowo JSON w prompcie i opisz oczekiwane klucze, jak w przykładzie. Tryb JSON gwarantuje składnię, nie Twój schemat, więc nadal zwaliduj sparsowany obiekt (np. z Pydantic) i obsłuż brakujący klucz.

Ograniczenia, strumieniowanie i koszt uruchomień agenta

Agenci wykonują wiele wywołań w krótkim czasie, więc limity konta są ważniejsze niż dla prostego czatbota. Pełny klucz pozwala na 8 równoległych zapytań i 300 zapytań na minutę. Klucz próbny pozwala na 2 i 60. Jeśli rozdzielasz wywołania przez batch lub uruchamiasz wiele agentów naraz, ogranicz równoległość w konfiguracji:

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
)
prompts = ["Name one prime number.", "Name one even number.", "Name one square number."]
answers = llm.batch(prompts, config={"max_concurrency": 8})
for a in answers:
    print(a.content)

Użyj 2 zamiast 8 na kluczu próbnym. Dla interaktywnych agentów llm.stream(...) zwraca tokeny przez SSE, gdy są generowane, a liczby użycia przychodzą na końcu strumienia.

Koszt łatwo oszacować. Uruchomienie 5-krokowe, które średnio zużywa 4 000 tokenów wejściowych i 300 tokenów wyjściowych na krok, zużywa łącznie 20 000 tokenów wejściowych i 1 500 tokenów wyjściowych, co daje $0,003 + $0,00075 = $0,00375 za uruchomienie przy cenie $0,15 i $0,50 za 1 mln tokenów. Na stronie z cenami znajdziesz stawki, a dokumentacja wymienia parametry i nagłówki zapytania, w tym X-Request-Id do śledzenia pojedynczego nieudanego wywołania.

Projektowanie narzędzi, których może użyć model

Większość niepowodzeń agentów wynika z narzędzi, a nie pętli. Kilka zasad pomaga przy każdym modelu:

  • Utrzymuj każde narzędzie wąskie. Narzędzie o nazwie get_order_status działa lepiej niż jedno o nazwie database_query, które przyjmuje tekst wolnej formy.
  • Używaj prostych typów argumentów: stringów, liczb całkowitych i krótkich enumów. Głęboko zagnieżdżone obiekty dają modelowi więcej sposobów na błędne wskazanie pola.
  • Zwracaj krótkie, proste wyniki. Narzędzie, które wstrzykuje 50 000 znaków do rozmowy, wypełnia okno kontekstu i podnosi koszt każdego kolejnego kroku.
  • Zwracaj błędy jako tekst, np. "order_id musi wyglądać jak A100", zamiast podnosić wyjątki, które kończą uruchomienie.

Przetestuj agenta na kilku prawdziwych promptach z kredytem próbnym $0,50 przed skalowaniem. Nowi użytkownicy otrzymują go jednym kliknięciem na stronie kluczy i jest ważny przez 7 dni.

Pułapki do sprawdzenia jako pierwsze

  • Wywołanie narzędzia nigdy się nie pojawia. Zrób docstring bardziej specyficzny, obniż temperaturę lub wymuś wywołanie z tool_choice.
  • Nieprawidłowe argumenty. Zweryfikuj dane wewnątrz narzędzia i zwróć jasny komunikat o błędzie, aby model mógł je poprawić w kolejnym kroku.
  • Wzrost kontekstu. Okno ma 100 000 tokenów włącznie z odpowiedzią. Obetnij stare wyniki narzędzi przed wypełnieniem okna.

Pytania i odpowiedzi

Która klasa LangChain działa z tym API?

ChatOpenAI z langchain-openai. Ustaw base_url na https://api.unlimitedaiapi.com/v1, model na uncensored i przekaż swój klucz jako api_key.

Czy API obsługuje wywoływanie funkcji dla agentów?

Tak. Akceptuje parametry tools i tool_choice, zwraca tool_calls (również przy strumieniowaniu) i przyjmuje wyniki jako wiadomości z rolą tool.

Czy LangChain może parsować dane strukturalne przez to API?

Tak, poprzez tryb JSON: ustaw response_format na typ json_object. Zapewnia to poprawną składnię JSON, więc zweryfikuj pola samodzielnie.

Ile agentów mogę uruchomić równolegle?

Pełny klucz pozwala na 8 równoległych zapytań i 300 na minutę. Klucz próbny pozwala na 2 równoległe zapytania i 60 na minutę.

Twój klucz jest o jeden formularz stąd

Utwórz konto, skopiuj klucz, zmień bazowy URL. To cała konfiguracja.

Pobierz klucz API