PT ▾

Uncensored Model HubModelos open source do LangChain via API sem censura

Modelos open source do LangChain via API sem censura

O LangChain funciona com modelos open source através de qualquer servidor compatível com OpenAI, e uma API hospedada poupa você de executar GPUs você mesmo. Aqui está a configuração em Python e Node, com ferramentas, um agente, saída JSON, streaming e um plano de concorrência.

Atualizado

Elos de corrente de vidro conectando blocos modulares a um cubo de servidor, ilustrando LangChain com uma API de modelo de pesos abertos

Pontos principais

  1. Use ChatOpenAI com base_url definida para https://api.uncensoredmodelhub.com/v1 e modelo uncensored.
  2. Chamada de ferramentas, modo JSON e streaming funcionam todas através das interfaces padrão do LangChain.
  3. Limite max_concurrency em 8 para uma chave completa, 2 para uma chave de teste, para evitar erros 429.
  4. O preço é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, sem assinatura.

Conecte o LangChain em quatro linhas

Se você quer usar modelos open source do LangChain sem hospedar nada, o caminho mais curto é uma API compatível com OpenAI. A classe de chat OpenAI do LangChain não se importa com quem responde, desde que o endpoint fale o mesmo protocolo. Você altera a base URL e a chave, e o resto das suas cadeias, prompts e agentes permanece igual.

Este serviço hospeda um único modelo de pesos abertos, executado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto legal. Não é a API oficial de nenhum fornecedor de modelo e não é um roteador entre fornecedores. Instale o pacote e crie o objeto do modelo:

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)

Essa é a conexão inteira. Mantenha a chave em uma variável de ambiente em projetos reais e leia-a com os.environ em vez de escrevê-la no arquivo. Se você ainda não tem uma chave, a página de chaves mostra como entrar e reivindicar $0,50 de crédito de teste, sem necessidade de cartão.

Node.js e LangChain.js

O pacote JavaScript segue a mesma ideia, com a base URL passada por meio de um objeto de configuração.

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);

Se você vir um 404 ou uma página HTML no erro, a base URL geralmente está incorreta. Ela deve terminar em /v1. Os dois endpoints por trás disso são POST /v1/chat/completions e GET /v1/models, e nada mais é necessário para o modelo de chat do LangChain.

Um modelo open source no LangChain é melhor hospedado ou local?

O LangChain também pode executar modelos open em sua própria máquina, por exemplo, através do Ollama ou de um servidor local. Essa rota tem vantagens reais, e é honesto dizer isso. Modelos locais não têm custo por token, funcionam offline e mantêm todos os bytes no seu hardware. O preço é o hardware: você precisa de memória de GPU suficiente para o modelo que escolher, mantém o runtime e o throughput é limitado pela sua máquina.

PerguntaServidor localEsta API hospedada
Custo inicialHardware ou GPU alugadaNenhum; crédito pré-pago a partir de $20
Custo por tokenNenhum, mas desgaste de energia e hardware$0,15 por 1M de entrada, $0,50 por 1M de saída
Janela de contextoDepende da memória disponível100.000 tokens
ConcorrênciaDepende da sua configuração8 para uma chave completa
Localização dos dadosSua máquinaHospedado; prompts não usados para treinamento

Um padrão comum é prototipar contra o endpoint hospedado e decidir, com contagens reais de tokens, se uma implantação local faz sentido. Como ambos os lados falam o protocolo OpenAI, a troca é uma alteração de linha única em base_url, e as cadeias que você construiu permanecem intactas. A página sobre o que é um modelo sem censura explica o que os ajustes mudam no comportamento.

Ferramentas e um agente simples

A chamada de ferramentas passa pelo campo tools no estilo OpenAI normal, e o bind_tools do LangChain constrói isso para você a partir de uma função Python decorada. O modelo retorna solicitações de chamada de ferramenta, e os resultados voltam como mensagens 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)

O loop do agente chama o modelo, executa a ferramenta quando solicitado e envia a saída de volta até que o modelo responda em texto simples. Duas cautelas se aplicam. Forneça uma docstring para cada ferramenta escrita para o modelo, porque esse é o texto que ele lê para escolher uma ferramenta. E defina um limite de recursão nos agentes para que uma execução confusa não continue gastando crédito; o LangGraph aceita um recursion_limit na configuração.

Para controle direto sem um agente, use llm.bind_tools([word_count]) e inspecione .tool_calls na mensagem retornada você mesmo.

Saída estruturada com modo JSON

Para tarefas de extração, passe o parâmetro do modo JSON através de bind. O prompt deve dizer ao modelo quais chaves você quer, pois o modo JSON apenas o empurra a produzir um objeto JSON válido.

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)

Valide o resultado com Pydantic ou uma verificação simples de chave antes de usá-lo. O modo não impõe um schema, então um campo ausente é possível, e uma nova tentativa com um prompt mais claro geralmente corrige isso.

Streaming e concorrência

O streaming roda sobre eventos enviados pelo servidor e funciona com o método stream padrão. O uso é enviado no final do stream.

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

Quando você processa muitos itens, batch os executa em paralelo, e é aqui que os limites importam. Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 e 60. Uma solicitação streaming mantém seu slot até o stream terminar. Passe um limite para que o LangChain nunca exceda o que sua chave permite:

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

Se você ainda vir HTTP 429, o código de erro indica qual limite você atingiu: rate_limited para requisições por minuto, concurrency para muitos ao mesmo tempo. Um 429 com um cabeçalho Retry-After: 5 marca sobrecarga temporária. ChatOpenAI tem uma opção max_retries que tenta novamente nesses erros com backoff; defina para 3 ou 4 para trabalhos em lote.

Uma cadeia de recuperação sem um endpoint de embeddings

Esta API cobre apenas geração, então uma cadeia de recuperação precisa de dois provedores: um para embeddings e outro para a etapa de chat. O LangChain facilita isso, porque o vector store e o modelo de chat são objetos separados. Use qualquer modelo de embedding que quiser, de uma biblioteca local ou outro serviço, para indexar seus documentos. Em seguida, passe o texto recuperado para o modelo de chat por meio do 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?"})

Aqui top_chunks é o que seu retriever retornou. Mantenha apenas os poucos trechos que importam. Quatro chunks de 300 tokens adicionam 1.200 tokens por chamada, o que é aceitável, mas quarenta chunks adicionam 12.000 e tornam cada requisição dez vezes mais pesada.

Lista de verificação de solução de problemas

  • Erros de autenticação: confirme se a chave está em api_key, não em um parâmetro diferente, e se nenhuma variável de ambiente OPENAI_API_KEY está substituindo silenciosamente o que você pretendia passar.
  • Modelo não encontrado: o ID do modelo é exatamente uncensored. Chame GET /v1/models para ver o que o servidor lista.
  • Argumentos de ferramenta estranhos: leia a string de argumentos bruta, refine a descrição da ferramenta e reduza a temperatura para cerca de 0,2 para execuções de agente.
  • Rastreamento e depuração: ative o modo verbose ou debug do LangChain localmente para ver cada prompt enviado e cada resposta recebida.
  • Testes repetíveis: passe seed e uma temperatura baixa quando comparar versões de prompt, para que as diferenças venham da sua alteração e não da sorte da amostragem.

Custo de uma carga de trabalho do LangChain

A cobrança é por token a partir do crédito pré-pago. Não há assinatura, requisições falhas ou recusadas não são cobradas, e o crédito nunca expira. Os recarregamentos podem ser qualquer valor inteiro de $20 a $500, por cripto (USDT na rede TRC20, USDC na rede Base), com bônus de 5% a partir de $50, 10% a partir de $100 e 15% a partir de $200. A página de preços tem os detalhes.

Resolva um exemplo. Um bot de suporte responde a 2.000 perguntas em um dia. Cada solicitação envia cerca de 1.500 tokens (prompt do sistema, snippets recuperados, pergunta) e retorna cerca de 250 tokens.

  • Entrada: 2.000 x 1.500 = 3.000.000 tokens, então 3 x $0,15 = $0,45.
  • Saída: 2.000 x 250 = 500.000 tokens, então 0,5 x $0,50 = $0,25.
  • Total: $0,70 por dia para 2.000 respostas, ou $0,00035 cada.

Cadeias de recuperação são onde os custos podem variar, porque cada chunk recuperado extra adiciona tokens de entrada a cada chamada. Registre usage_metadata das respostas, monitore o tamanho médio do prompt e reduza a contagem de chunks antes de escalar. A documentação da API lista todos os parâmetros suportados se você quiser ir além.

Perguntas e respostas

Qual classe do LangChain devo usar para esta API?

Use ChatOpenAI de langchain-openai em Python ou @langchain/openai em JavaScript. Defina o modelo como uncensored e aponte base_url para https://api.uncensoredmodelhub.com/v1.

Suporta agentes e chamada de funções?

Sim. A chamada de funções usa o formato de ferramentas no estilo OpenAI, então bind_tools e agentes LangGraph funcionam. Valide os argumentos das ferramentas você mesmo, já que o modelo os retorna como texto.

Qual é a janela de contexto para cadeias no LangChain?

100.000 tokens, compartilhados entre prompt e conclusão. Buffers de memória longa e muitos chunks recuperados consomem essa capacidade, então reduza o histórico na sua cadeia.

Os embeddings estão disponíveis para meu repositório vetorial?

Não. A API é apenas para chat de texto, sem embeddings, imagens, áudio ou fine-tuning. Use um provedor de embeddings separado para recuperação e esta API para a etapa de geração.

Sua chave está a um formulário de distância

Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.

Obter chave de API