PT ▾

openaiapiproxy.comLangChain URL base do OpenAI: use uma API LLM personalizada

LangChain URL base do OpenAI: use uma API LLM personalizada

A URL base do langchain openai é um argumento do construtor no ChatOpenAI. Defina-o para https://api.openaiapiproxy.com/v1, passe sua chave e use o nome do modelo uncensored, e toda cadeia e agente que aceita um modelo de chat o executará.

Atualizado

Uma cadeia de links luminosos terminando em uma esfera brilhante, representando um pipeline LangChain conectado a um modelo personalizado

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_metadata na 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.

  1. Imprima os metadados da resposta. A mensagem retornada por invoke carrega response_metadata e usage_metadata. Você pode verificar a razão de término e as contagens de tokens sem nenhuma configuração extra.
  2. Ative o log de depuração. set_debug(True) de langchain_core.globals imprime cada prompt e resposta em uma cadeia. Use-o apenas no desenvolvimento, porque ele imprime os prompts completos.
  3. 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.

Perguntas e respostas

Qual é o nome do modelo a usar no LangChain?

Use uncensored. É o único ID de modelo, e GET /v1/models o retorna.

É ChatOpenAI ou OpenAI que recebe a URL base?

Use ChatOpenAI de langchain-openai para conclusões de chat. Ele recebe base_url em Python e configuration.baseURL em JavaScript.

Posso usar OpenAIEmbeddings com este endpoint?

Não. Embeddings não são oferecidos, então aponte a classe de embeddings para um serviço diferente.

Por que recebo HTTP 429 em um lote?

Você excedeu 8 requisições simultâneas ou 300 requisições por minuto com uma chave completa, ou 2 e 60 com uma chave de teste. Defina max_concurrency e confie nos retries.

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