Pontos principais
- Em Python, use ChatOpenAI(base_url=..., api_key=..., model="uncensored"). Em JavaScript, use configuration.baseURL.
- Prompts, cadeias, streaming, vinculação de ferramentas e modo JSON continuam funcionando pelas interfaces padrão.
- Embeddings não são oferecidos, então OpenAIEmbeddings deve apontar para um serviço diferente.
- Use max_concurrency 8 com uma chave completa e deixe as retentativas lidar com as respostas 429.
A alteração de duas linhas
Ao pesquisar a URL base do langchain openai, a resposta é curta. A classe de chat OpenAI do LangChain envolve o SDK OpenAI, e esse SDK aceita uma URL base personalizada. Aponte-o para este serviço e nada mais na sua cadeia precisará ser alterado. Instale os pacotes com pip install langchain-openai langchain-core primeiro.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.openaiapiproxy.com/v1",
api_key="YOUR_KEY",
temperature=0.8,
)
print(llm.invoke("Describe a rainy harbor town in two sentences.").content)Essa é a integração completa. O serviço é compatível com OpenAI, mas é um produto separado: um único modelo de pesos abertos, executado por um provedor independente, sem recusas de conteúdo para uso adulto legal. Não é a API oficial da OpenAI ou de qualquer outro fornecedor. Para obter uma chave, use a página chave de API; novas contas podem resgatar um crédito de teste de $0,50 com um clique, sem cartão.
Por que isso funciona: ChatOpenAI constrói solicitações padrão de conclusão de chat e as envia para qualquer endereço que lhe foi dado. O serviço responde com a forma de resposta padrão, então os objetos de mensagem, callbacks e analisadores do LangChain se comportam como o fazem contra qualquer outro provedor. Você mantém as mesmas abstrações e apenas o destino muda. Como o destino é um modelo diferente, você deve re-testar seus prompts. Um prompt escrito para persuadir um modelo restritivo a cooperar pode ser desnecessário aqui, e instruções mais curtas geralmente funcionam melhor.
Variáveis de ambiente ou argumentos explícitos
Você pode configurar a mesma coisa através do ambiente, e isso é útil para implantações. O SDK OpenAI lê OPENAI_BASE_URL e OPENAI_API_KEY. A documentação mais antiga do LangChain usava OPENAI_API_BASE para o mesmo propósito. Como os nomes mudaram entre versões, o hábito mais seguro é passar base_url e api_key explicitamente e ler sua própria variável.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.openaiapiproxy.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
max_retries=3,
timeout=120,
)Um benefício real de argumentos explícitos: se o seu projeto também usa outro provedor para outras tarefas, uma variável global solta não pode redirecionar esse tráfego para o lugar errado. Dois objetos ChatOpenAI com URLs base diferentes vivem felizmente no mesmo processo.
A mesma configuração no LangChain.js
No pacote JavaScript, a URL base vai dentro de um objeto configuration que é passado para o SDK subjacente.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.UNCENSORED_API_KEY,
configuration: {
baseURL: "https://api.openaiapiproxy.com/v1",
},
});
const res = await llm.invoke("Give me three names for a haunted ship.");
console.log(res.content);A capitalização é a armadilha usual: Python usa base_url, o SDK JavaScript usa baseURL.
Um prompt, um modelo e um analisador
Uma vez que o modelo de chat está pronto, a linguagem de expressão do LangChain funciona normalmente. Essa cadeia transforma um tópico em uma cena curta e retorna uma string simples.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You write short scenes for an adult fiction platform."),
("human", "Write a scene about: {topic}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"topic": "two smugglers meeting at a closed customs office"}))
for piece in chain.stream({"topic": "a stormy night at a mountain inn"}):
print(piece, end="", flush=True)O streaming depende dos eventos enviados pelo servidor do serviço, que chegam conforme o modelo os gera. Uma chamada em streaming ocupa um slot de concorrência até ser concluída.
O operador | compõe executáveis, então a mesma cadeia pode posteriormente ganhar um recuperador, uma segunda chamada de modelo ou um analisador de saída sem tocar nas etapas anteriores. Se você mover um prompt entre provedores, mantenha o prompt em um arquivo para poder versioná-lo separadamente das configurações do endpoint.
Chamada de funções e saída JSON
O LangChain transforma funções Python em esquemas de ferramentas com o decorador @tool e as envia através do parâmetro padrão tools. O serviço suporta tools, tool_choice e tool_calls em streaming, então bind_tools funciona.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def lookup_character(name: str) -> str:
"""Return the notes for a character in the story bible."""
notes = {"Mara": "A ferry pilot with a fear of deep water."}
return notes.get(name, "No notes.")
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([lookup_character])
reply = llm_tools.invoke("What do we know about Mara?")
for call in reply.tool_calls:
print(call["name"], call["args"])
print(lookup_character.invoke(call["args"]))Para o modo JSON, vincule o formato de resposta e mencione JSON em suas instruções:
import json
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke("Return a JSON object with keys title and summary for a pirate novel.")
print(json.loads(msg.content))Mesmo com o modo JSON, envolva a análise em tratamento de erros. Independentemente do provedor, a saída malformada acontece ocasionalmente, e uma única tentativa com o erro de análise anexado geralmente corrige isso.
Histórico de chat e documentos longos
Os modelos de chat do LangChain recebem uma lista de mensagens, e o histórico é seu para gerenciar. As classes de mensagem tornam os papéis explícitos, o que é mais claro do que tuplas quando um prompt tem várias partes.
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
messages = [
SystemMessage(content="You are the narrator of a slow-burn mystery."),
HumanMessage(content="Open with the detective arriving in town."),
]
first = llm.invoke(messages)
messages.append(AIMessage(content=first.content))
messages.append(HumanMessage(content="Now introduce the suspicious innkeeper."))
second = llm.invoke(messages)
print(second.content)
print(second.usage_metadata)A janela de contexto é de 100.000 tokens, prompt e conclusão juntos. Isso é espaço para históricos de chat longos, uma ficha de personagem e várias páginas de texto de referência em uma única chamada. Isso não significa que você deve preenchê-lo sempre. Tokens de entrada são faturados a $0,15 por 1M, então um prompt de 60.000 tokens custa 60.000 / 1.000.000 x $0,15 = $0,009 por chamada antes do modelo escrever uma palavra. Uma etapa de recuperação que envia apenas as três páginas relevantes é mais barata e geralmente fornece respostas melhores.
Quando um prompt é construído a partir de muito texto recuperado, lembre-se do limite de 8 MB no corpo da requisição. Está muito acima do que a janela de tokens permite para texto normal, então você geralmente atingirá o limite de tokens primeiro, mas dados colados com strings longas e ininterruptas podem se comportar de forma diferente.
Limites de requisições, lotes e agentes
O LangChain torna o trabalho paralelo fácil, o que é exatamente como você atinge os limites por acidente. Uma chave completa permite 8 requisições simultâneas e 300 por minuto. Uma chave de teste permite 2 e 60. Use o argumento config para limitar o paralelismo em lotes.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
titles = llm.batch(
[f"Suggest a title for episode {i} of a space western." for i in range(1, 25)],
config={"max_concurrency": 8},
)
for t in titles:
print(t.content)Se você vir HTTP 429, o código de erro indica o motivo: rate_limited para requisições por minuto, concurrency para muitas ao mesmo tempo. Em sobrecarga temporária, a resposta inclui Retry-After: 5. A lógica de tentativas no SDK subjacente cuida da maioria disso, mas agentes que disparam muitas chamadas de ferramentas em paralelo ainda podem saturar uma chave de teste, então reduza max_concurrency para 2 lá.
Loop de agentes: cada etapa envia a conversa crescente de volta como entrada, então os tokens de entrada se acumulam mais rápido do que os tokens de saída. A $0,15 por 1M de entrada e $0,50 por 1M de saída, uma execução de agente que envia 60.000 tokens de entrada no total e produz 6.000 tokens de saída custa 60.000 / 1.000.000 x $0,15 + 6.000 / 1.000.000 x $0,50 = $0,009 + $0,003 = $0,012. A página de preços mostra os tamanhos de recarga.
O que não mantém compatibilidade
- Embeddings. Não há endpoint de embeddings. Se sua cadeia de recuperação é construída sobre
OpenAIEmbeddings, use outra fonte de embeddings para essa parte e mantenha apenas o modelo de chat aqui. - Imagens e áudio. O serviço é apenas texto.
- Troca de modelo. Há um modelo,
uncensored. Um menu suspenso de nomes de modelos de fornecedores não corresponderá. - Contagem de tokens por nome. Bibliotecas que estimam contagens de tokens pelo nome do modelo podem cair em uma aproximação. Para números reais, leia
usage_metadatana mensagem de resposta.
A janela de contexto é de 100.000 tokens para prompt e conclusão juntos, o que é generoso para históricos de chat longos e preenchimento de documentos. Verifique a documentação para a lista completa de parâmetros, e lembre-se de que o modelo não recusa conteúdo adulto legal, então adicione seus próprios filtros a qualquer cadeia voltada ao público. A regra rígida é sem conteúdo sexual envolvendo menores de idade.
Depuração de uma cadeia com comportamento incorreto
Quando uma cadeia produz uma saída estranha, descubra o que realmente passou pela rede antes de alterar o prompt. Três ferramentas ajudam, em ordem de esforço.
- Imprima os metadados da resposta. A mensagem retornada por
invokecarregaresponse_metadataeusage_metadata. Você pode verificar a razão de término e as contagens de tokens sem nenhuma configuração extra. - Ative o log de depuração.
set_debug(True)delangchain_core.globalsimprime cada prompt e resposta em uma cadeia. Use-o apenas no desenvolvimento, porque ele imprime os prompts completos. - Replay a chamada com curl. Copie as mensagens renderizadas da saída de depuração para uma solicitação para
https://api.openaiapiproxy.com/v1/chat/completions. Se o curl se comportar da mesma forma, o problema está no seu prompt. Se diferir, o problema está na cadeia.
Sintomas típicos e onde procurar: um erro not-found geralmente significa que a URL base tem um /v1 duplicado ou está faltando. Uma mensagem sobre um modelo desconhecido significa que o nome não é uncensored. Listas vazias de tool_calls geralmente significam que o prompt não deixou claro que a ferramenta deve ser usada, o que uma descrição de ferramenta mais clara corrige. E um agente que trava pode simplesmente estar em fila atrás de suas próprias chamadas paralelas em uma chave de teste, então reduza a concorrência.
Mantenha uma nota do cabeçalho ID da solicitação (X-Request-Id) das falhas. Se um problema for do lado do serviço, a página de suporte explica como relatá-lo, e esse ID acelera as coisas.
