PL ▾

Uncensored Model HubModele open source LangChain przez API bez cenzury

Modele open source LangChain przez API bez cenzury

LangChain współpracuje z modelami open source przez dowolny serwer kompatybilny z OpenAI, a API hostowane oszczędza Ci uruchamiania GPU. Oto konfiguracja w Pythonie i Node, z narzędziami, agentem, wyjściem JSON, strumieniowaniem i planem współbieżności.

Zaktualizowano

Szklane ogniwa łańcucha łączące modułowe bloki z sześcianem serwera, ilustrujące LangChain z API modelu o otwartych wagach

Kluczowe punkty

  1. Użyj ChatOpenAI z base_url ustawionym na https://api.uncensoredmodelhub.com/v1 i modelem uncensored.
  2. Wywoływanie narzędzi, tryb JSON i strumieniowanie działają przez standardowe interfejsy LangChain.
  3. Ogranicz max_concurrency do 8 dla pełnego klucza i do 2 dla klucza próbnego, aby uniknąć błędów 429.
  4. Ceny to $0,15 za 1M tokenów wejściowych i $0,50 za 1M tokenów wyjściowych, bez subskrypcji.

Połącz LangChain w czterech liniach

Jeśli chcesz używać modeli open source LangChain bez hostowania czegokolwiek, najkrótszą drogą jest API kompatybilne z OpenAI. Klasie czatu OpenAI w LangChain jest obojętne, kto odpowiada, o ile endpoint mówi tym samym protokołem. Zmieniasz base URL i klucz, a reszta Twoich łańcuchów, promptów i agentów pozostaje bez zmian.

Usługa hostuje jeden model o otwartych wagach, uruchamiany przez niezależnego dostawcę i dostrojony do odpowiadania bez odmów treści dla zgodnego z prawem użytku przez dorosłych. Nie jest to oficjalne API żadnego dostawcy modeli i nie jest routerem między dostawcami. Zainstaluj pakiet i stwórz obiekt modelu:

pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.uncensoredmodelhub.com/v1",
    api_key="YOUR_API_KEY",
    temperature=0.7,
)

print(llm.invoke("Give me three names for a fantasy tavern.").content)

To całe połączenie. W rzeczywistych projektach przechowuj klucz w zmiennej środowiskowej i odczytuj go za pomocą os.environ zamiast wpisywać go do pliku. Jeśli jeszcze nie masz klucza, na stronie klucza zobaczysz, jak się zarejestrować i odebrać $0,50 kredytu próbnego, bez konieczności podawania karty.

Node.js i LangChain.js

Pakiet JavaScript podąża za tą samą ideą, z base URL przekazywanym przez obiekt konfiguracji.

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.API_KEY,
  temperature: 0.7,
  configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});

const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);

Jeśli widzisz błąd 404 lub stronę HTML, base URL jest zwykle błędny. Musi kończyć się na /v1. Dwa endpointy w tle to POST /v1/chat/completions i GET /v1/models, a nic więcej nie jest potrzebne do modelu czatu LangChain.

Czy model open source w LangChain jest lepszy na hostowanym czy lokalnym?

LangChain może też uruchamiać modele open source na Twojej maszynie, np. przez Ollama lub lokalny serwer. Ta droga ma realne zalety i uczciwie jest to powiedzieć. Modele lokalne nie mają opłaty za token, działają offline i trzymają każdy bajt na Twoim sprzęcie. Ceną jest sprzęt: potrzebujesz wystarczającej pamięci GPU dla wybranego modelu, utrzymujesz środowisko uruchomieniowe, a przepustowość jest ograniczona przez Twoją maszynę.

PytanieSerwer lokalnyTo hostowane API
Koszt początkowySprzęt lub wynajęte GPUBrak; przedpłacony kredyt od $20
Koszt za tokenBrak, ale zużycie energii i zużycie sprzętu$0,15 za 1M wejście, $0,50 za 1M wyjście
Okno kontekstuZależy od dostępnej pamięci100 000 tokenów
Równoległe zapytaniaZależy od Twojej konfiguracji8 dla pełnego klucza
Lokalizacja danychTwoja maszynaHostowane; prompty nie są używane do trenowania

Powszechnym wzorcem jest prototypowanie na hostowanym endpointzie, a następnie podjęcie decyzji na podstawie rzeczywistej liczby tokenów, czy lokalne wdrożenie ma sens. Ponieważ obie strony obsługują protokół OpenAI, przełączenie to zmiana jednej linii w base_url, a zbudowane przez Ciebie łańcuchy pozostają bez zmian. Strona o tym, czym jest model bez cenzury wyjaśnia, co dostrojenie zmienia w zachowaniu.

Narzędzia i prosty agent

Wywoływanie narzędzi odbywa się przez standardowe pole tools w stylu OpenAI, a bind_tools w LangChain tworzy to za Ciebie na podstawie dekorowanej funkcji Python. Model zwraca żądania wywołania narzędzi, a wyniki wracają jako komunikaty role: "tool".

from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

@tool
def word_count(text: str) -> int:
    '''Count the words in a piece of text.'''
    return len(text.split())

agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)

Pętla agenta wywołuje model, uruchamia narzędzie, gdy poprosi, i wysyła wynik z powrotem, aż model odpowie zwykłym tekstem. Obowiązują dwa zastrzeżenia. Daj każdemu narzędziu docstring napisany dla modelu, bo to tekst, który czyta, by wybrać narzędzie. I ustaw limit rekurencji na agentach, aby zagubione wykonanie nie mogło nieustannie wydawać kredytu; LangGraph akceptuje recursion_limit w konfiguracji.

Dla bezpośredniej kontroli bez agenta użyj llm.bind_tools([word_count]) i sam zbadaj .tool_calls na zwróconym komunikacie.

Wyjście strukturalne w trybie JSON

Dla zadań ekstrakcji przekaż parametr trybu JSON przez bind. Prompt musi powiedzieć modelowi, jakie klucze chcesz, ponieważ tryb JSON jedynie nakłania go do wygenerowania poprawnego obiektu JSON.

import json
from langchain_core.prompts import ChatPromptTemplate

json_llm = llm.bind(response_format={"type": "json_object"})

prompt = ChatPromptTemplate.from_messages([
    ("system", "Return a JSON object with keys title, genre and summary."),
    ("human", "{idea}"),
])

chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)

Zweryfikuj wynik za pomocą Pydantic lub prostym sprawdzeniem klucza przed użyciem. Tryb nie wymusza schematu, więc brak pola jest możliwy, a ponowne wywołanie z klarowniejszym promptem zwykle to naprawia.

Strumieniowanie i współbieżność

Strumieniowanie działa przez zdarzenia wysyłane przez serwer i współpracuje ze standardową metodą stream. Użycie jest wysyłane na końcu strumienia.

for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
    print(chunk.content, end="", flush=True)

Gdy przetwarzasz wiele elementów, batch uruchamia je równolegle, i tu granice mają znaczenie. Pełny klucz pozwala na 8 równoległych zapytań i 300 zapytań na minutę. Klucz próbny pozwala na 2 i 60. Zapytanie strumieniowe trzyma swój slot, aż strumień się skończy. Przekaż limit, aby LangChain nigdy nie przekroczył tego, co pozwala Twój klucz:

prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})

Jeśli nadal widzisz HTTP 429, kod błędu informuje, który limit przekroczyłeś: rate_limited dla zapytań na minutę, concurrency dla zbyt wielu naraz. 429 z nagłówkiem Retry-After: 5 oznacza tymczasowe przeciążenie. ChatOpenAI ma opcję max_retries, która ponawia próbę przy takich błędach z backoff; ustaw ją na 3 lub 4 dla zadań wsadowych.

Łańcuch pobierania bez endpointu embeddingów

To API obejmuje tylko generowanie, więc łańcuch pobierania potrzebuje dwóch dostawców: jednego dla embeddingów i jednego dla kroku czatu. LangChain to ułatwia, bo repozytorium wektorowe i model czatu to osobne obiekty. Użyj dowolnego modelu embeddingów, z lokalnej biblioteki lub innej usługi, aby zindeksować dokumenty. Następnie przekaż pobrany tekst do modelu czatu przez prompt.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
    ("human", "{question}"),
])

chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})

Tutaj top_chunks to dowolne wyniki, które zwrócił Twój retriever. Ogranicz je do kilku istotnych fragmentów. Cztery fragmenty po 300 tokenów dodają 1200 tokenów na każde zapytanie, co jest w porządku, ale czterdzieści fragmentów dodaje 12 000 tokenów i sprawia, że każde zapytanie jest dziesięciokrotnie cięższe.

Lista rozwiązywania problemów

  • Błędy uwierzytelniania: upewnij się, że klucz znajduje się w api_key, a nie w innym parametrze, oraz że żadna zmienna środowiskowa OPENAI_API_KEY nie nadpisuje cicho tego, co chciałeś przekazać.
  • Model nie znaleziony: identyfikator modelu to dokładnie uncensored. Wywołaj GET /v1/models, aby zobaczyć, co serwer wyświetla.
  • Dziwne argumenty narzędzi: przeczytaj surowy ciąg argumentów, doprecyzuj opis narzędzia i obniż temperaturę do około 0,2 dla uruchomień agenta.
  • Śledzenie i debugowanie: włącz tryb verbose lub debug LangChain lokalnie, aby zobaczyć każdy wychodzący prompt i każdą powracającą odpowiedź.
  • Powtarzalne testy: przekaż seed i niską temperaturę, gdy porównujesz wersje promptów, aby różnice wynikały z Twojej zmiany, a nie z przypadku przy próbkowaniu.

Koszt obciążenia LangChain

Rozliczenie następuje za tokeny z przedpłaconego kredytu. Nie ma subskrypcji, nieudane lub odrzucone zapytania nie są rozliczane, a kredyt nigdy nie wygasa. Doładowania to dowolna kwota całkowita od $20 do $500, kryptowalutami (USDT na TRC20, USDC na Base), z bonusem 5% od $50, 10% od $100 i 15% od $200. Strona cennika zawiera szczegóły.

Przeanalizuj przykład. Bot wsparcia odpowiada na 2000 pytań w ciągu dnia. Każde zapytanie wysyła około 1500 tokenów (prompt systemowy, pobrane fragmenty, pytanie) i zwraca około 250 tokenów.

  • Wejście: 2000 x 1500 = 3 000 000 tokenów, więc 3 x $0,15 = $0,45.
  • Wyjście: 2000 x 250 = 500 000 tokenów, więc 0,5 x $0,50 = $0,25.
  • Razem: $0,70 dziennie za 2000 odpowiedzi, albo $0,00035 za każdą.

Łańcuchy pobierania to miejsce, w którym koszty mogą rosnąć, ponieważ każdy dodatkowy pobrany fragment dodaje tokeny wejściowe do każdego zapytania. Zaloguj usage_metadata z odpowiedzi, obserwuj średni rozmiar promptu i ogranicz liczbę fragmentów przed skalowaniem. Dokumentacja API zawiera listę wszystkich obsługiwanych parametrów, jeśli chcesz pójść dalej.

Pytania i odpowiedzi

Którą klasę LangChain użyć dla tego API?

Użyj ChatOpenAI z langchain-openai w Pythonie lub @langchain/openai w JavaScript. Ustaw model na uncensored i wskaż base_url na https://api.uncensoredmodelhub.com/v1.

Czy obsługuje agentów i wywoływanie narzędzi?

Tak. Wywoływanie narzędzi używa formatu narzędzi w stylu OpenAI, więc bind_tools i agenci LangGraph działają. Waliduj argumenty narzędzi samodzielnie, ponieważ model zwraca je jako tekst.

Jakie jest okno kontekstu dla łańcuchów LangChain?

100 000 tokenów, współdzielonych przez prompt i completion. Długie bufory pamięci i wiele pobranych fragmentów zużywają go, więc przycinaj historię w swoim łańcuchu.

Czy embeddingi są dostępne dla mojego repozytorium wektorowego?

Nie. API obsługuje tylko czat tekstowy, bez embeddingów, obrazów, audio ani fine-tuningu. Użyj oddzielnego dostawcy embeddingów do pobierania i tego API do etapu generowania.

Twój klucz jest o jeden formularz stąd

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

Pobierz klucz API