Chat OpenAI no LangChain com uma API sem censura

Pontos principais

ChatOpenAI precisa de três configurações: base_url, api_key e model definidos como uncensored.
Streaming, chamada de ferramentas e modo JSON passam pelas interfaces padrão do LangChain.
Limite a concorrência a 8 e trate HTTP 429 com tentativas para permanecer dentro dos limites.
Uma execução de agente com dez etapas custa bem menos de um centavo a $0,15 e $0,50 por 1M de tokens.

A resposta curta: três configurações no ChatOpenAI

Se você pesquisou por chat open ai langchain, provavelmente tem um projeto LangChain que já usa ChatOpenAI e quer que ele converse com um backend diferente. Isso é uma alteração de configuração, não uma reescrita. A API deste site fala o protocolo de conclusões de chat OpenAI, então o LangChain o trata como qualquer outro servidor estilo OpenAI.

Você precisa da URL base, sua chave de API e o ID do modelo uncensored. Instale os pacotes primeiro:

pip install -U langchain-openai langgraph

Depois, crie o objeto do modelo:

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
    temperature=0.8,
)

reply = llm.invoke("Write a two-sentence villain monologue for a heist novel.")
print(reply.content)

Essa é a integração completa. Cada recurso do LangChain baseado em ChatOpenAI agora executa contra o modelo sem censura: chains, retrievers que chamam o modelo de chat, output parsers e agents. Se você ainda não tem uma chave, a página chave de API explica o cadastro e o crédito de teste com um clique.

Mantenha a chave fora do seu código

Coloque a chave em uma variável de ambiente e leia-a na inicialização. No Linux ou macOS:

export NOFILTER_API_KEY="paste-your-key-here"

Crie um único módulo de cliente compartilhado para o projeto, por exemplo llm.py que constrói o modelo uma vez e o exporta. Cada chain então importa o mesmo objeto, e uma alteração posterior de chave, timeout ou temperatura ocorre em um único lugar. Isso também facilita manter uma segunda instância mais fria para tool steps e uma mais quente para escrita criativa, ambas apontando para o mesmo endpoint com configurações diferentes.

Uma armadilha pega muitas pessoas: ChatOpenAI também lê OPENAI_API_KEY e OPENAI_API_BASE do ambiente. Se essas variáveis estiverem definidas para outro projeto, um objeto parcialmente configurado pode enviar sua solicitação para o servidor errado. Passar base_url e api_key explicitamente, como acima, remove a ambiguidade.

Você pode confirmar a conexão sem o LangChain. O endpoint de modelos deve retornar uma única entrada:

curl https://api.nofilteraichat.com/v1/models \
  -H "Authorization: Bearer $NOFILTER_API_KEY"

Se isso funcionar mas o LangChain falhar, o problema está no seu ambiente Python, não na chave. Se ambos falharem com 401, verifique se há um espaço ou nova linha na chave. O guia de início lista o formato exato da solicitação para comparação.

Streaming e uso de tokens

UIs de chat ficam melhores quando os tokens aparecem conforme são gerados. O LangChain expõe isso através de .stream(), e o servidor envia chunks SSE padrão quando stream: true está definido internamente.

from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
    stream_usage=True,
)

final = None
for chunk in llm.stream("Describe a rainy harbour town in four sentences."):
    print(chunk.content, end="", flush=True)
    final = chunk if final is None else final + chunk

print()
print(final.usage_metadata)

Com stream_usage=True o último chunk carrega contagens de tokens de entrada e saída, que a API envia no final do stream. Mantenha esses números. Eles são a maneira mais barata de ver quanto um agente realmente custa, e usamos eles na seção de custos abaixo.

Uma coisa a lembrar: uma solicitação em streaming ocupa seu slot de concorrência até que o stream termine. Se você abandonar um stream sem fechá-lo, esse slot fica ocupado por mais tempo do que você espera.

Node e TypeScript

O pacote JavaScript usa um nome de opção ligeiramente diferente. A URL base vai dentro de configuration:

npm install @langchain/openai @langchain/core

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.NOFILTER_API_KEY,
  configuration: { baseURL: "https://api.nofilteraichat.com/v1" },
  temperature: 0.8,
});

const res = await llm.invoke("Give me three names for a smuggler's ship.");
console.log(res.content);

Os tipos TypeScript para a resposta são as classes de mensagem padrão do LangChain, então o código existente que lê res.content ou res.usage_metadata continua funcionando. Quando você executa isso dentro de uma rota de servidor, construa o modelo uma vez no escopo do módulo em vez de por solicitação. Isso evita criar um novo cliente HTTP para cada chamada e mantém sua concorrência fácil de entender.

Todo o resto, incluindo .stream(), .bindTools() e .withStructuredOutput(), se comporta da mesma forma que em Python. Temperatura, top_p, sequências de parada, seed e as opções de penalidade são passadas para o modelo, então você pode defini-las no construtor como faria para qualquer outro backend estilo OpenAI.

Chamada de ferramentas e um pequeno agente

A API suporta chamada de ferramentas: os campos tools e tool_choice, tool_calls em streaming, e resultados de ferramentas retornados como mensagens role: "tool". O agente pré-construído do LangGraph usa exatamente esse loop. Aqui está um agente com uma ferramenta:

import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

@tool
def roll_dice(sides: int) -> int:
    """Roll a die with the given number of sides."""
    import random
    return random.randint(1, sides)

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
)

agent = create_react_agent(llm, [roll_dice])
out = agent.invoke(
    {"messages": [("user", "Roll a twenty-sided die twice and tell me the total.")]}
)
print(out["messages"][-1].content)

O uso de ferramentas com modelos de pesos abertos é menos previsível do que com um modelo principal hospedado, então trate isso como algo para testar. Escreva descrições de ferramentas em palavras simples, mantenha esquemas de argumentos pequenos e defina temperature baixo (0,2 a 0,4) para etapas de agente que devem produzir argumentos válidos. Se uma chamada retornar malformada, o LangChain a expõe como uma chamada de ferramenta inválida, e uma tentativa com uma descrição mais clara geralmente corrige isso.

Mantenha o loop do agente limitado. O LangGraph tem um limite de recursão, e você deve defini-lo para um número que possa pagar. Se um agente puder chamar ferramentas para sempre, um prompt ruim pode queimar créditos enquanto você está longe do teclado. Um limite de 10 a 15 etapas é um padrão sensato para a maioria das tarefas, e você pode passá-lo na configuração quando invocar o agente.

Saída estruturada

O modo JSON está disponível através de response_format. No LangChain, peça por ele com o método de modo JSON e nomeie as chaves no seu prompt:

from pydantic import BaseModel
from langchain_openai import ChatOpenAI
import os

class Character(BaseModel):
    name: str
    role: str
    secret: str

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
)
structured = llm.with_structured_output(Character, method="json_mode")
print(structured.invoke(
    "Return JSON with keys name, role and secret for a noir detective."
))

Limites de requisições, retries e custo

Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 e 60. Quando você excede qualquer um desses limites, a API responde com HTTP 429 e um código de erro: rate_limited para requisições por minuto, concurrency para muitas ao mesmo tempo. Sobrecarga temporária também retorna 429, com um cabeçalho Retry-After: 5.

O LangChain oferece dois controles para isso. max_retries no modelo faz tentativas de chamadas falhas com backoff, e max_concurrency na configuração de execução limita trabalho em lote paralelo:

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilteraichat.com/v1",
    api_key=os.environ["NOFILTER_API_KEY"],
    max_retries=4,
    timeout=120,
)

answers = llm.batch(
    ["Prompt one", "Prompt two", "Prompt three", "Prompt four"],
    config={"max_concurrency": 6},
)

Definir max_concurrency para 6 em uma chave completa deixa margem para um segundo processo. Lembre-se de que cada etapa de agente é uma solicitação separada, e uma etapa em streaming ocupa sua slot até que o stream termine.

Quanto custa uma execução de agente

O preço é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída. Digamos que uma etapa de agente envie 3.000 tokens de histórico, ferramentas e instruções, e o modelo escreva 500 tokens. A entrada custa 3.000 × $0,15 / 1.000.000 = $0,00045. A saída custa 500 × $0,50 / 1.000.000 = $0,00025. Uma etapa é $0,0007. Uma execução de dez etapas é $0,007, e 1.000 dessas execuções custam $7,00.

Agents reenviam seu histórico crescente em cada etapa, então tokens de entrada dominam. O trim de output de ferramentas antigo é a otimização mais barata que você tem. Requisições falhas ou recusadas não são cobradas. Detalhes de recargas e bônus estão na página de preços.

Problemas comuns

404 em todas as chamadas. A URL base deve terminar em /v1 e não deve incluir /chat/completions. O LangChain anexa o caminho sozinho.
Modelo não encontrado. O único ID de modelo é uncensored. Nomes como gpt-4o não funcionarão.
Erros de contexto. A janela é de 100.000 tokens para prompt mais conclusão. Cadeias de recuperação longas podem excedê-la. Resuma ou corte antes de enviar.
Solicitação muito grande. O limite do corpo é 8 MB, o que importa se você enche prompts com documentos inteiros.
Falhas em embeddings. Esta API é apenas chat de texto. Mantenha seu modelo de embedding em outro provedor e use este endpoint para geração.

O mesmo padrão funciona para outras estruturas e interfaces de chat; o guia de integração cobre mais clientes. Para qualquer coisa incomum, a página de suporte é o lugar para começar.

Mais guias

Obter chave de API

Perguntas e respostas

Posso usar ChatOpenAI com uma URL base personalizada?

Sim. Passe base_url (baseURL dentro da configuração no Node), sua chave e o modelo uncensored. O LangChain não se importa qual servidor responde, desde que siga o protocolo de chat OpenAI.

O streaming do LangChain funciona com esta API?

Sim. A API faz streaming via SSE e envia o uso no final, então .stream() e astream() funcionam, e stream_usage=True fornece contagens de tokens.

Posso usar embeddings ou armazenamentos vetoriais do LangChain com ele?

Não para embeddings, porque a API não tem endpoint de embeddings. Use outra fonte de embedding para recuperação e envie o texto recuperado para este endpoint para geração.

O que acontece quando eu atingo o limite de requisições?

Você recebe HTTP 429 com o código rate_limited ou concurrency. Defina max_retries no ChatOpenAI e limite max_concurrency para 8 ou menos em uma chave completa.

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