Czego potrzebujesz przed rozpoczęciem
LangChain komunikuje się z każdym serwerem implementującym protokół chat completions OpenAI, więc nie ma potrzeby instalowania specjalnej integracji. Twoim punktem wyjścia jest ten sam pakiet, którego użyłbyś dla samego OpenAI: langchain-openai dla Pythona lub @langchain/openai dla Node. Zmieniają się tylko trzy wartości.
- Base URL:
https://api.deepseekapipricing.com/v1 - Model:
uncensored - Klucz: przesyłany jako
Authorization: Bearer <key>, co klient robi za Ciebie
Wyjaśnienie dotyczące nazewnictwa. Ten endpoint to niezależna usługa uruchamiająca jeden model o otwartych wagach, dostrojony do odpowiadania bez odmów dotyczących treści, do zgodnego z prawem użytku przez dorosłych. Nie jest to oficjalne API DeepSeek ani router między dostawcami, więc nazwa modelu to zawsze uncensored, a nie identyfikator modelu dostawcy. Jeśli potrzebujesz klucza, strona klucz API pokazuje kroki rejestracji i jednorazowy kredyt próbny za $0,50.
Zainstaluj i wykonaj pierwsze wywołanie w Pythonie
Zainstaluj pakiety:
pip install -U langchain-openai langchain-core
# then use base_url https://api.deepseekapipricing.com/v1 and model "uncensored"
Następnie stwórz obiekt modelu. Przekaż klucz jawnie zamiast polegać na zmiennej środowiskowej OPENAI_API_KEY, która może zawierać prawdziwy klucz OpenAI, którego nie chcesz wysyłać do innego hosta.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.deepseekapipricing.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
temperature=0.7,
max_retries=2,
)
print(llm.invoke("Say hello in five words.").content)
Jeśli wyświetli się powitanie, połączenie, klucz i nazwa modelu są poprawne. Najczęstszym błędem na tym etapie jest pominięcie /v1 w base URL, co zwykle powoduje błąd not-found.
Prompty, łańcuchy i strumieniowanie
Od tego momentu LangChain działa jak zwykle. Prompt template, model i parser wyjścia tworzą łańcuch za pomocą operatora pipe:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You write tight, vivid scene descriptions for adult fiction."),
("human", "Describe this setting in under 80 words: {setting}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"setting": "a flooded subway station at night"}))
Strumieniowanie odbywa się za pomocą zdarzeń wysyłanych przez serwer. W LangChain wywołujesz stream, a każdy chunk zawiera fragment tekstu. Ustaw stream_usage=True w modelu, jeśli chcesz otrzymywać liczbę tokenów na końcu strumienia; API wysyła zużycie w ostatnim zdarzeniu.
llm_stream = ChatOpenAI(
model="uncensored",
base_url="https://api.deepseekapipricing.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
stream_usage=True,
)
for chunk in llm_stream.stream("Write a four-line poem about a night train."):
print(chunk.content, end="", flush=True)
Zapytanie strumieniowe zajmuje slot concurrency do momentu zakończenia strumienia, więc jeśli porzucisz strumień bez jego zamknięcia, ten slot pozostanie zajęty dłużej niż się spodziewasz.
Node i TypeScript
Pakiet JavaScript przyjmuje base URL wewnątrz obiektu configuration:
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.UNCENSORED_API_KEY,
configuration: { baseURL: "https://api.deepseekapipricing.com/v1" },
maxRetries: 2,
});
const res = await llm.invoke("Say hello in five words.");
console.log(res.content);
const stream = await llm.stream("Write a four-line poem about a night train.");
for await (const chunk of stream) {
process.stdout.write(chunk.content);
}
Uruchom go jako moduł ES ("type": "module" w package.json lub plik .mjs). Wszystko inne w API Node, w tym prompt template i runnables, zachowuje się tak samo jak w przypadku dowolnego innego modelu czatu.
Wywoływanie funkcji i agenci
API obsługuje format narzędzi OpenAI: parametry tools i tool_choice, strumieniowane tool_calls oraz wyniki narzędzi zwracane jako wiadomości z role: "tool". W LangChain deklarujesz narzędzia za pomocą dekoratora i dołączasz je za pomocą bind_tools:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage
@tool
def order_status(order_id: str) -> str:
"""Return the shipping status of an order."""
return f"Order {order_id} left the warehouse yesterday."
llm_tools = llm.bind_tools([order_status])
messages = [HumanMessage("Where is order 1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)
for call in ai.tool_calls:
result = order_status.invoke(call["args"])
messages.append(ToolMessage(content=result, tool_call_id=call["id"]))
print(llm_tools.invoke(messages).content)
Napisanie pętli ręcznie raz jest warte dziesięciu minut. Pokazuje dokładnie, co zwrócił model, jakie argumenty wybrał dla każdego wywołania i gdzie zły opis narzędzia prowadzi do błędnej odpowiedzi. Gdy to będzie jasne, przełącz się na gotowego agenta i zachowaj wersję ręczną jako odniesienie do debugowania.
To jest cała pętla ręcznie: model prosi o narzędzie, ty je wykonujesz, zwracasz wynik, a model pisze ostateczną odpowiedź. Jeśli wolisz gotową pętlę agenta, pakiet langgraph oferuje create_react_agent(llm, [order_status]), a wywołujesz go za pomocą {"messages": [("user", "Where is order 1042?")]}.
Dobór narzędzi przez model zależy od modelu, więc przetestuj go na swoich rzeczywistych schematach narzędzi. Krótkie, konkretne opisy narzędzi i niska temperatura pomagają. Agent wykonujący sześć wywołań z rosnącą historią o łącznej liczbie około 27 000 tokenów wejściowych i 1 800 tokenów wyjściowych kosztuje około $0,00405 plus $0,0009, czyli około pół centa.
Wyjście strukturalne w trybie JSON
Tryb JSON jest obsługiwany przez response_format. Powiąż go z modelem i również napisz w prompcie, że chcesz JSON z konkretnymi kluczami, ponieważ flaga formatu kontroluje składnię, nie Twój schemat:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
import json
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke(
"Return a JSON object with keys title (string) and tags (list of 3 strings) "
"for a short story about a lighthouse keeper."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])
Zweryfikuj sparsowany wynik za pomocą Pydantic lub własnych sprawdzeń, zanim mu zaufasz, i obsłuż json.JSONDecodeError jedną ponowną próbą. Przy dużych zadaniach ekstrakcji parsuj każdą odpowiedź defensywnie, a nie zakładaj, że pierwsza jest poprawna.
Pobieranie, pamięć i callbacki
To API nie ma endpointu embeddingów, więc pipeline pobierania wymaga oddzielnego źródła embeddingów. Wszystko po pobieraniu to zwykła rozmowa. Typowy łańcuch pobierania pobiera najlepsze fragmenty z Twojego magazynu wektorowego, wkleja je do promptu i prosi model o odpowiedź na podstawie tego tekstu. Ponieważ okno kontekstu wynosi 100 000 tokenów, możesz pozwolić sobie na obszerne fragmenty, ale pamiętaj o rachunku: każdy token pobranego kontekstu to input po $0,15 za milion, więc 20 000 tokenów kontekstu kosztuje $0,003 za pytanie.
W przypadku pamięci czatu najprostszym podejściem jest lista wiadomości, którą przycinasz według liczby tokenów przed każdym wywołaniem. LangChain oferuje pomocniki takie jak trim_messages do tego celu. Zachowaj wiadomość systemową i najnowsze tury, a usuń lub podsumuj środek, gdy historia osiągnie limit, który wybierzesz. Mniejsza historia utrzymuje również odpowiedzi skupione i obniża koszt każdej tury, ponieważ cała historia jest wysyłana jako input za każdym razem.
Callbacki to miejsce do rejestrowania kosztu wywołania. Każda odpowiedź zawiera blok usage z tokenami prompt i completion, a w LangChain zwrócona wiadomość zawiera go w usage_metadata:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
msg = llm.invoke("Name three rivers.")
u = msg.usage_metadata
cost = u["input_tokens"] * 0.15 / 1_000_000 + u["output_tokens"] * 0.50 / 1_000_000
print(u, f"${cost:.6f}")
Zaloguj koszt z ID żądania, aby zaskakujący rachunek można było prześledzić do jednego łańcucha.
Prompty systemowe i ton
Model nie ma wbudowanych odmów treści, więc wiadomość systemowa jest miejscem, w którym ustawiasz zachowanie swojego produktu: persona, ton, tematy, których powinien unikać i format odpowiedzi. Napisz ją tak, jakbyś pisał brief dla nowego współpracownika. Krótkie i konkretne działa lepiej niż długie i niejasne. Treści dotyczące nieletnich to sztywny limit tej usługi, więc nie buduj promptów, które do tego dążą.
Krótka lista kontrolna przed wdrożeniem
- Klucz znajduje się w zmiennej środowiskowej lub magazynie sekretów, nigdy w repozytorium.
max_concurrencyjest ustawione na limit Twojego klucza lub poniżej niego, jeśli inne usługi współdzielą klucz.- Ponowne próby używają krótkiego back-off, a odpowiedzi 429 z
Retry-After: 5są respektowane. - Strumienie są zamykane przy rozłączeniu klienta, aby zwolnić sloty.
- Wyjścia JSON są parsowane defensywnie i walidowane.
- Koszty są logowane na poziomie łańcucha z bloku usage.
- Istnieje fallback na przypadek, gdy endpoint jest nieosiągalny, nawet jeśli fallbackiem jest komunikat o błędzie.
Postępuj zgodnie z tą listą, a integracja będzie zachowywać się jak dowolny inny model czatu LangChain. Różnica leży po stronie treści, gdzie żądania, które inne modele odrzucają do zgodnego z prawem użytku przez dorosłych, otrzymują odpowiedź.
Limity zapytań, concurrency i typowe błędy
Pełny klucz pozwala na 8 równoległych zapytań i 300 zapytań na minutę. Klucz próbny pozwala na 2 równoległe zapytania i 60 na minutę. Treść zapytania (body) może mieć do 8 MB, a okno kontekstu wynosi 100 000 tokenów obejmujących prompt i completion łącznie.
Pomocniki batch LangChain wysyłają zapytania równolegle, więc ustaw górny limit pasujący do Twojego klucza:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
inputs = [{"setting": s} for s in ["a rooftop garden", "a desert diner", "a quiet harbor"]]
results = chain.batch(inputs, config={"max_concurrency": 8})
Użyj 2 zamiast 8 na kluczu próbnym. Gdy przekroczysz limit, API zwraca HTTP 429 z kodem błędu rate_limited (zbyt wiele zapytań na minutę) lub concurrency (zbyt wiele naraz). Przy tymczasowym przeciążeniu zwraca również 429 z nagłówkiem Retry-After: 5. Ustawienie max_retries w kliencie obsługuje przypadki przejściowe, ale jeśli widzisz kod błędu concurrency wielokrotnie, zmniejsz max_concurrency zamiast dodawać ponowne próby.
- Błędy not-found przy każdym wywołaniu: sprawdź, czy base URL kończy się na
/v1. - Błąd uwierzytelniania: klucz jest brakujący lub ma literówkę; potwierdź, że jest przekazywany przez
api_key. - Błędy modelu: nazwa modelu musi być dokładnie
uncensored. - Powolne zadania batchowe: zablokowane strumienie zajmują sloty współbieżności, więc zamknij je lub ustaw limit czasu.
Ceny wynoszą $0,15 za milion tokenów wejściowych i $0,50 za milion tokenów wyjściowych, a nieudane lub odrzucone zapytania nie są rozliczane. Na stronie z cenami znajdziesz informacje o doładowaniach, a dokumentacja omawia każdy parametr i nagłówki odpowiedzi, w tym X-Request-Id oraz X-Balance-USD, które przydadzą się do logowania w callbacku LangChain.
