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.

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_statusdziała lepiej niż jedno o nazwiedatabase_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.
Więcej przewodników
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.