PL ▾
Pobierz klucz API
https://api.deepseekapipricing.com/v1

Konfiguracja LangChain dla API DeepSeek: Python i Node

Do konfiguracji langchain dla api deepseek potrzebujesz tylko klasy ChatOpenAI, base URL, klucza i nazwy modelu. Ten przewodnik obejmuje kod Python i Node do czatu, strumieniowania, wywoływania funkcji, wyjścia JSON i concurrency, używając niezależnego endpointu kompatybilnego z OpenAI zamiast własnego API dostawcy.

Zaktualizowano

Świecące ogniwa łączące serwery z dymkami czatu, reprezentujące integrację LangChain z API

Kluczowe punkty

  1. Użyj ChatOpenAI z base_url ustawionym na https://api.deepseekapipricing.com/v1 i modelem uncensored.
  2. Przekaż api_key jawnie, aby klucz OpenAI w Twoim środowisku nie został nigdy tutaj wysłany.
  3. Strumieniowanie, bind_tools i tryb JSON działają przez standardowe parametry formatu OpenAI.
  4. Ogranicz max_concurrency do 8 dla pełnego klucza lub do 2 dla klucza próbnego, aby uniknąć błędów 429.

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_concurrency jest 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: 5 są 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.

01

Pytania i odpowiedzi

Której klasy LangChain powinienem użyć?

Użyj ChatOpenAI z langchain-openai w Pythonie lub ChatOpenAI z @langchain/openai w Node. Ustaw Base URL na https://api.deepseekapipricing.com/v1 i model na uncensored.

Czy strumieniowanie działa z LangChain?

Tak. API przesyła strumieniowo przez SSE i wysyła zużycie na końcu, więc llm.stream działa. Ustaw stream_usage=True, jeśli chcesz otrzymywać liczbę tokenów w strumieniu.

Czy mogę użyć embeddingów lub magazynów wektorowych?

Nie z tego API. Obsługuje tylko tekst i nie ma endpointu embeddingów, więc użyj osobnego źródła embeddingów do pobierania i przesyłaj pobrany tekst tutaj.

Dlaczego otrzymuję HTTP 429?

Przekroczyłeś limit na minutę (rate_limited), wysłałeś zbyt wiele zapytań naraz (concurrency) lub dostawca był chwilowo przeciążony. Zmniejsz max_concurrency i respektuj nagłówek Retry-After.

Twój klucz jest o jeden formularz stąd

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

Pobierz klucz API