PT ▾

Comece com o crédito de teste

E-mail e senha; a chave aparece na hora na tela.

https://api.uncensoredllmhub.com/v1

API LLM com LangChain: Conectar um endpoint personalizado

Para configurar uma API LLM com LangChain, você só precisa de ChatOpenAI, uma URL base, uma chave e um ID de modelo. Esta página mostra cadeias, streaming, chamada de funções e saída estruturada contra este endpoint compatível com OpenAI, com código que você pode copiar.

Atualizado

Elas são elos de corrente de vidro conectados a um cubo de servidor, ilustrando cadeias LangChain chamando um endpoint de LLM personalizado
Rack de servidor e balança de equilíbrio com moedas ao lado de uma nuvem brilhante, comparando auto-hospedagem com uma API

Pontos principais

  • ChatOpenAI aceita base_url, api_key e model, então qualquer endpoint compatível com OpenAI funciona.
  • Use a URL base https://api.uncensoredllmhub.com/v1 e o modelo uncensored.
  • A chamada de funções é suportada; para saída estruturada, o modo JSON é o método mais seguro.
  • Respeite os limites: 8 requisições simultâneas para uma chave completa, então limite a concorrência do seu lote.

Instalar e conectar

A integração do LangChain com OpenAI é um pacote separado da biblioteca principal. Instale com pip install langchain-openai. Obtenha uma chave na página da chave de API; novos usuários podem reivindicar $0,50 de crédito de teste lá com um clique, sem necessidade de cartão.

Em seguida, crie o objeto do modelo. Três argumentos são importantes: model, base_url e api_key.

from langchain_openai import ChatOpenAI

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

print(llm.invoke("Give me three names for a lighthouse cat.").content)

Essa é toda a integração. Tudo o que vem depois, como prompts, parsers, agentes e retrievers, trata llm como qualquer outro modelo de chat. Se preferir variáveis de ambiente, o SDK do OpenAI lê OPENAI_API_KEY e OPENAI_BASE_URL, o que facilita alternar entre ambientes sem tocar no código.

O que o endpoint suporta

O serviço expõe POST /v1/chat/completions, POST /v1/responses e GET /v1/models. ChatOpenAI usa chat completions por padrão, que é a escolha segura. O modelo é um modelo de pesos abertos ajustado para responder sem recusas de conteúdo para uso adulto legal, com uma janela de contexto de 100.000 tokens compartilhada por prompt e conclusão.

Recursos de solicitação suportados dos quais o LangChain depende: streaming via SSE com uso no final, chamada de funções, modo JSON e os parâmetros de amostragem temperature, top_p, stop, seed e as penalidades. Não disponíveis: embeddings, geração de imagem ou áudio, fine-tuning. Se uma cadeia de recuperação precisar de embeddings, use um modelo de embedding diferente para essa etapa e mantenha este endpoint para geração. Notas completas sobre parâmetros estão na documentação.

Um prompt, um modelo e um analisador

O padrão básico LCEL encadeia um prompt no modelo e depois em um parser de saída. O streaming vem de graça com .stream().

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

llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a concise editor. Reply in {tone} tone."),
    ("human", "Improve this sentence: {text}"),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "plain", "text": "The thing was done by the team."}))

for piece in chain.stream({"tone": "friendly", "text": "We regret to inform you of a delay."}):
    print(piece, end="", flush=True)

A mensagem de sistema define o comportamento para cada chamada. Como a janela de contexto é grande, você também pode fornecer texto de referência longo através do modelo de prompt sem um separador em muitos casos. O custo de entrada é $0,15 por 1M de tokens, então um documento de 20.000 tokens no prompt custa 20.000 / 1.000.000 x $0,15 = $0,003 por chamada.

Chamada de funções

A chamada de funções segue o formato OpenAI: você passa definições de função, o modelo responde com tool_calls, você executa a função e retorna o resultado como uma mensagem com o papel de ferramenta. O LangChain envolve isso em bind_tools.

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b

llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([add])

msg = llm_tools.invoke("What is 41 plus 1? Use the tool.")
for call in msg.tool_calls:
    print(call["name"], call["args"])   # run the function yourself, then send a ToolMessage back

O modelo solicita a chamada; seu código a executa. Em um framework de agente como LangGraph, um loop faz isso para você até que o modelo responda em texto simples. Mantenha as descrições das ferramentas curtas e os nomes dos argumentos simples. Se o modelo ignorar uma ferramenta, refine o docstring e defina tool_choice para forçar a chamada enquanto depura.

Saída estruturada com modo JSON

O endpoint suporta o modo JSON, response_format: {"type":"json_object"}. No LangChain, solicite-o através de with_structured_output e escolha o método do modo JSON, depois valide com um modelo Pydantic.

from pydantic import BaseModel
from langchain_openai import ChatOpenAI

class Ticket(BaseModel):
    title: str
    priority: str

llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
structured = llm.with_structured_output(Ticket, method="json_mode")

print(structured.invoke("Return JSON with title and priority for: login page crashes on Safari, urgent."))

Dois hábitos tornam o JSON confiável. Primeiro, diga "JSON" e nomeie as chaves no prompt, já que o modo JSON garante sintaxe válida, mas não o seu esquema. Segundo, envolva a chamada em uma tentativa que capture erros de validação e envie o texto de erro de volta ao modelo uma vez. Não dependa da decodificação restrita ao esquema a menos que você a tenha testado com este endpoint.

Concorrência, tentativas e controle de custo

O LangChain facilita chamadas paralelas com .batch(), e é aí que os limites se aplicam. Uma chave completa permite 8 requisições simultâneas e 300 por minuto. Uma chave de teste permite 2 e 60. Passe config={"max_concurrency": 6} para batch para permanecer abaixo do limite.

Quando o limite é excedido, a API retorna HTTP 429 com código rate_limited ou concurrency, e um cabeçalho Retry-After: 5 em sobrecarga temporária. ChatOpenAI tem um argumento max_retries que lida com esses casos com backoff; defina-o para 3 a 5. Streams ocupam uma slot até terminarem, então não deixe streams parcialmente lidos abertos.

Exemplo de custo calculado: um trabalho em lote de 2.000 itens, cada um com 800 tokens de entrada e 150 tokens de saída. Entrada: 2.000 x 800 = 1.600.000 tokens = 1,6 x $0,15 = $0,24. Saída: 2.000 x 150 = 300.000 tokens = 0,3 x $0,50 = $0,15. O trabalho custa $0,39. Requisições falhas ou recusadas não são cobradas, e o cabeçalho X-Balance-USD permite que você acompanhe seu saldo. Veja preços para recargas, que variam de $20 a $500 e podem ser pagas por cripto.

Agentes e memória de conversa

Dois padrões surgem logo após a primeira cadeia funcionar. O primeiro é memória de conversa. Os auxiliares de histórico de mensagens do LangChain armazenam voltas passadas e as preparam para cada chamada. Como a janela é de 100.000 tokens, você pode manter históricos longos, mas lembre-se de que cada volta os reenvia. Um histórico de 30.000 tokens em cada uma de 50 voltas significa 1.500.000 tokens de entrada, ou 1,5 x $0,15 = $0,225 para a sessão. Resumir voltas antigas quando o histórico ultrapassa um limite de tamanho mantém isso plano.

O segundo é o loop do agente. No LangGraph, um agente pré-construído usa o mesmo objeto llm mais uma lista de ferramentas e faz loop até que o modelo pare de solicitar ferramentas. Defina um número máximo de etapas para que um loop confuso não acumule tokens de entrada. Registre o cabeçalho de resposta X-Request-Id para qualquer chamada que se comporte estranhamente, já que é o identificador a citar se você entrar em contato com suporte.

Solução de Problemas

  • 404 em todas as chamadas. A URL base deve terminar em /v1 e não deve incluir /chat/completions.
  • Modelo não encontrado. Use uncensored exatamente. O LangChain não valida nomes de modelos para endpoints personalizados.
  • Avisos de contagem de tokens. Alguns recursos do LangChain estimam tokens com tokenizers OpenAI. As contagens podem diferir ligeiramente do modelo real, então confie no uso retornado pela API.
  • Loops longos de agentes ficam caros. Cada loop reenvia o histórico completo. Remova saídas de ferramentas antigas antes que elas alcancem a próxima chamada.

Se sua cadeia parecer correta e ainda falhar, chame o endpoint com curl simples para separar um problema do LangChain de um problema da conta.

Perguntas e respostas

Qual classe do LangChain usar para um endpoint compatível com OpenAI?

ChatOpenAI do pacote langchain-openai, com base_url, api_key e modelo definidos.

A chamada de funções funciona com esta API?

Sim. Suporta ferramentas, tool_choice, tool_calls em streaming e resultados retornados com o papel de ferramenta.

Posso usar embeddings do LangChain com este endpoint?

Não. O serviço não possui endpoint de embeddings. Use outro provedor de embeddings ou um modelo local para essa etapa.

Como evitar erros 429 em lotes?

Defina max_concurrency abaixo de 8 para uma chave completa, ou abaixo de 2 para uma chave de teste, e permita algumas tentativas automáticas.

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

https://api.uncensoredllmhub.com/v1