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 backO 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
/v1e não deve incluir/chat/completions. - Modelo não encontrado. Use
uncensoredexatamente. 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.

